]> git.ipfire.org Git - thirdparty/vala.git/commitdiff
add interface documentation, use implicit namespace specification
authorJürg Billeter <j@bitron.ch>
Tue, 4 Jul 2006 08:43:43 +0000 (08:43 +0000)
committerJürg Billeter <juergbi@src.gnome.org>
Tue, 4 Jul 2006 08:43:43 +0000 (08:43 +0000)
2006-07-04  Jürg Billeter  <j@bitron.ch>

* vala/valacodevisitor.vala, vala/valaattributeprocessor.vala,
  vala/valabinaryexpression.vala: add interface documentation, use
  implicit namespace specification
* vala/valaassignment.vala, vala/valaattribute.vala: documentation
  corrections

svn path=/trunk/; revision=62

vala/ChangeLog
vala/vala/valaassignment.vala
vala/vala/valaattribute.vala
vala/vala/valaattributeprocessor.vala
vala/vala/valabinaryexpression.vala
vala/vala/valacodevisitor.vala

index 8fde26a25ecb640c54552ae012d4726b1d8aadff..248cc30ca6f7ed3dbdaac814a7d7f034ecece09d 100644 (file)
@@ -1,3 +1,11 @@
+2006-07-04  Jürg Billeter  <j@bitron.ch>
+
+       * vala/valacodevisitor.vala, vala/valaattributeprocessor.vala,
+         vala/valabinaryexpression.vala: add interface documentation, use
+         implicit namespace specification
+       * vala/valaassignment.vala, vala/valaattribute.vala: documentation
+         corrections
+
 2006-07-04  Jürg Billeter  <j@bitron.ch>
 
        * vala/valacodegenerator.vala: generate assignment with appropriate
index 4bb58f6dd860d38ef4f32f9460f6e0d801aaa94c..7304b2801941662415999ca1e8bb54f5e73447de 100644 (file)
@@ -48,6 +48,7 @@ public class Vala.Assignment : Expression {
         * @param op assignment operator
         * @param right right hand side
         * @param source reference to source code
+        * @return newly created assignment
         */
        public static ref Assignment! new (Expression! left, AssignmentOperator op, Expression! right, SourceReference source) {
                return (new Assignment (left = left, operator = op, right = right, source_reference = source));
index a8d79b3b7ac03bce33f8f5abff448893208516fd..21d7bd664ed76d6b8b0f2b78bbbbbf182188bdba 100644 (file)
@@ -41,6 +41,7 @@ public class Vala.Attribute : CodeNode {
         *
         * @param name attribute type name
         * @param source reference to source code
+        * @return newly created attribute
         */
        public static ref Attribute! new (string! name, SourceReference source) {
                return (new Attribute (name = name, source_reference = source));
index 6bcec093a5e1ce08d8fc602432bc79f2d9e56271..efecfbe76ab267de4b8e5896649e508fcf65aa8b 100644 (file)
 
 using GLib;
 
-namespace Vala {
-       public class AttributeProcessor : CodeVisitor {
-               public void process (CodeContext! context) {
-                       context.accept (this);
-               }
-
-               public override void visit_begin_namespace (Namespace! ns) {
-                       ns.process_attributes ();
-               }
-       
-               public override void visit_begin_struct (Struct! st) {
-                       st.process_attributes ();
-               }
-       
-               public override void visit_begin_class (Class! cl) {
-                       cl.process_attributes ();
-               }
-       
-               public override void visit_begin_enum (Enum! en) {
-                       en.process_attributes ();
-               }
-       
-               public override void visit_begin_method (Method! m) {
-                       m.process_attributes ();
-               }
-
-               public override void visit_begin_property (Property! prop) {
-                       prop.process_attributes ();
-               }
-       
-               public override void visit_field (Field! f) {
-                       f.process_attributes ();
-               }
+/**
+ * Code visitor processing attributes associated with code nodes.
+ */
+public class Vala.AttributeProcessor : CodeVisitor {
+       /**
+        * Process all attributes found in specified code context.
+        *
+        * @param context a code context
+        */
+       public void process (CodeContext! context) {
+               context.accept (this);
+       }
+
+       public override void visit_begin_namespace (Namespace! ns) {
+               ns.process_attributes ();
+       }
+
+       public override void visit_begin_struct (Struct! st) {
+               st.process_attributes ();
+       }
+
+       public override void visit_begin_class (Class! cl) {
+               cl.process_attributes ();
+       }
+
+       public override void visit_begin_enum (Enum! en) {
+               en.process_attributes ();
+       }
+
+       public override void visit_begin_method (Method! m) {
+               m.process_attributes ();
+       }
+
+       public override void visit_begin_property (Property! prop) {
+               prop.process_attributes ();
+       }
+
+       public override void visit_field (Field! f) {
+               f.process_attributes ();
        }
 }
index a3e561717d5a609cc35520dd34e4143529ae4872..0f825b9c998f466718ca21a32a4fbde6724ec4a1 100644 (file)
 
 using GLib;
 
-namespace Vala {
-       public class BinaryExpression : Expression {
-               public BinaryOperator operator { get; set construct; }
-               public Expression! left { get; set construct; }
-               public Expression! right { get; set construct; }
-               
-               public static ref BinaryExpression! new (BinaryOperator op, Expression! left, Expression! right, SourceReference source) {
-                       return (new BinaryExpression (operator = op, left = left, right = right, source_reference = source));
-               }
-               
-               public override void accept (CodeVisitor! visitor) {
-                       left.accept (visitor);
-                       right.accept (visitor);                 
-
-                       visitor.visit_binary_expression (this);
-               }
+/**
+ * Represents an expression with two operands in the source code.
+ */
+public class Vala.BinaryExpression : Expression {
+       /**
+        * The binary operator.
+        */
+       public BinaryOperator operator { get; set; }
+       
+       /**
+        * The left operand.
+        */
+       public Expression! left { get; set construct; }
+       
+       /**
+        * The right operand.
+        */
+       public Expression! right { get; set construct; }
+       
+       /**
+        * Creates a new binary expression.
+        *
+        * @param op binary operator
+        * @param left left operand
+        * @param right right operand
+        * @param source reference to source code
+        * @return newly created binary expression
+        */
+       public static ref BinaryExpression! new (BinaryOperator op, Expression! left, Expression! right, SourceReference source) {
+               return (new BinaryExpression (operator = op, left = left, right = right, source_reference = source));
        }
        
-       public enum BinaryOperator {
-               PLUS,
-               MINUS,
-               MUL,
-               DIV,
-               MOD,
-               SHIFT_LEFT,
-               SHIFT_RIGHT,
-               LESS_THAN,
-               GREATER_THAN,
-               LESS_THAN_OR_EQUAL,
-               GREATER_THAN_OR_EQUAL,
-               EQUALITY,
-               INEQUALITY,
-               BITWISE_AND,
-               BITWISE_OR,
-               BITWISE_XOR,
-               AND,
-               OR
+       public override void accept (CodeVisitor! visitor) {
+               left.accept (visitor);
+               right.accept (visitor);                 
+
+               visitor.visit_binary_expression (this);
        }
 }
+
+public enum Vala.BinaryOperator {
+       PLUS,
+       MINUS,
+       MUL,
+       DIV,
+       MOD,
+       SHIFT_LEFT,
+       SHIFT_RIGHT,
+       LESS_THAN,
+       GREATER_THAN,
+       LESS_THAN_OR_EQUAL,
+       GREATER_THAN_OR_EQUAL,
+       EQUALITY,
+       INEQUALITY,
+       BITWISE_AND,
+       BITWISE_OR,
+       BITWISE_XOR,
+       AND,
+       OR
+}
index cf773a97e29044eb59576b3560ee55ba805720f1..fda8d1f5738eea218c400ec9d8210160ab46f6a8 100644 (file)
 
 using GLib;
 
-namespace Vala {
-       public abstract class CodeVisitor {
-               public virtual void visit_begin_source_file (SourceFile! source_file) {
-               }
+/**
+ * Abstract code node visitor for traversing source code tree.
+ */
+public abstract class Vala.CodeVisitor {
+       /**
+        * Visit operation called at beginning of source files.
+        *
+        * @param source_file a source file
+        */
+       public virtual void visit_begin_source_file (SourceFile! source_file) {
+       }
 
-               public virtual void visit_end_source_file (SourceFile! source_file) {
-               }
+       /**
+        * Visit operation called at end of source files.
+        *
+        * @param source_file a source file
+        */
+       public virtual void visit_end_source_file (SourceFile! source_file) {
+       }
 
-               public virtual void visit_begin_namespace (Namespace! ns) {
-               }
+       /**
+        * Visit operation called at beginning of namespaces.
+        *
+        * @param ns a namespace
+        */
+       public virtual void visit_begin_namespace (Namespace! ns) {
+       }
 
-               public virtual void visit_end_namespace (Namespace! ns) {
-               }
+       /**
+        * Visit operation called at end of namespaces.
+        *
+        * @param ns a namespace
+        */
+       public virtual void visit_end_namespace (Namespace! ns) {
+       }
 
-               public virtual void visit_begin_class (Class! cl) {
-               }
+       /**
+        * Visit operation called at beginning of classes.
+        *
+        * @param cl a class
+        */
+       public virtual void visit_begin_class (Class! cl) {
+       }
 
-               public virtual void visit_end_class (Class! cl) {
-               }
+       /**
+        * Visit operation called at end of classes.
+        *
+        * @param cl a class
+        */
+       public virtual void visit_end_class (Class! cl) {
+       }
 
-               public virtual void visit_begin_struct (Struct! st) {
-               }
+       /**
+        * Visit operation called at beginning of structs.
+        *
+        * @param st a struct
+        */
+       public virtual void visit_begin_struct (Struct! st) {
+       }
 
-               public virtual void visit_end_struct (Struct! st) {
-               }
+       /**
+        * Visit operation called at end of structs.
+        *
+        * @param st a struct
+        */
+       public virtual void visit_end_struct (Struct! st) {
+       }
 
-               public virtual void visit_begin_interface (Interface! iface) {
-               }
+       /**
+        * Visit operation called at beginning of interfaces.
+        *
+        * @param iface an interface
+        */
+       public virtual void visit_begin_interface (Interface! iface) {
+       }
 
-               public virtual void visit_end_interface (Interface! iface) {
-               }
+       /**
+        * Visit operation called at end of interfaces.
+        *
+        * @param iface an interface
+        */
+       public virtual void visit_end_interface (Interface! iface) {
+       }
 
-               public virtual void visit_begin_enum (Enum! en) {
-               }
+       /**
+        * Visit operation called at beginning of enums.
+        *
+        * @param en an enum
+        */
+       public virtual void visit_begin_enum (Enum! en) {
+       }
 
-               public virtual void visit_end_enum (Enum! en) {
-               }
+       /**
+        * Visit operation called at end of enums.
+        *
+        * @param en an enum
+        */
+       public virtual void visit_end_enum (Enum! en) {
+       }
 
-               public virtual void visit_enum_value (EnumValue! ev) {
-               }
+       /**
+        * Visit operation called for enum values.
+        *
+        * @param ev an enum value
+        */
+       public virtual void visit_enum_value (EnumValue! ev) {
+       }
 
-               public virtual void visit_begin_flags (Flags! fl) {
-               }
+       /**
+        * Visit operation called at beginning of flags.
+        *
+        * @param fl a flags
+        */
+       public virtual void visit_begin_flags (Flags! fl) {
+       }
 
-               public virtual void visit_end_flags (Flags! fl) {
-               }
+       /**
+        * Visit operation called at end of flags.
+        *
+        * @param fl a flags
+        */
+       public virtual void visit_end_flags (Flags! fl) {
+       }
 
-               public virtual void visit_flags_value (FlagsValue! fv) {
-               }
+       /**
+        * Visit operation called for flags values.
+        *
+        * @param fv an flags value
+        */
+       public virtual void visit_flags_value (FlagsValue! fv) {
+       }
 
-               public virtual void visit_begin_callback (Callback! cb) {
-               }
+       /**
+        * Visit operation called at beginning of callbacks.
+        *
+        * @param cb a callback
+        */
+       public virtual void visit_begin_callback (Callback! cb) {
+       }
 
-               public virtual void visit_end_callback (Callback! cb) {
-               }
+       /**
+        * Visit operation called at end of callbacks.
+        *
+        * @param cb a callback
+        */
+       public virtual void visit_end_callback (Callback! cb) {
+       }
 
-               public virtual void visit_constant (Constant! c) {
-               }
+       /**
+        * Visit operation called for constants.
+        *
+        * @param c a constant
+        */
+       public virtual void visit_constant (Constant! c) {
+       }
 
-               public virtual void visit_field (Field! f) {
-               }
+       /**
+        * Visit operation called for fields.
+        *
+        * @param f a field
+        */
+       public virtual void visit_field (Field! f) {
+       }
 
-               public virtual void visit_begin_method (Method! m) {
-               }
+       /**
+        * Visit operation called at beginning of methods.
+        *
+        * @param m a method
+        */
+       public virtual void visit_begin_method (Method! m) {
+       }
 
-               public virtual void visit_end_method (Method! m) {
-               }
+       /**
+        * Visit operation called at end of methods.
+        *
+        * @param m a method
+        */
+       public virtual void visit_end_method (Method! m) {
+       }
 
-               public virtual void visit_formal_parameter (FormalParameter! p) {
-               }
+       /**
+        * Visit operation called for formal parameters.
+        *
+        * @param p a formal parameter
+        */
+       public virtual void visit_formal_parameter (FormalParameter! p) {
+       }
 
-               public virtual void visit_begin_property (Property! prop) {
-               }
+       /**
+        * Visit operation called at beginning of properties.
+        *
+        * @param prop a property
+        */
+       public virtual void visit_begin_property (Property! prop) {
+       }
 
-               public virtual void visit_end_property (Property! prop) {
-               }
+       /**
+        * Visit operation called at end of properties.
+        *
+        * @param prop a property
+        */
+       public virtual void visit_end_property (Property! prop) {
+       }
 
-               public virtual void visit_begin_property_accessor (PropertyAccessor! acc) {
-               }
+       /**
+        * Visit operation called at beginning of property accessors.
+        *
+        * @param acc a property accessor
+        */
+       public virtual void visit_begin_property_accessor (PropertyAccessor! acc) {
+       }
 
-               public virtual void visit_end_property_accessor (PropertyAccessor! acc) {
-               }
+       /**
+        * Visit operation called at end of property accessors.
+        *
+        * @param acc a property accessor
+        */
+       public virtual void visit_end_property_accessor (PropertyAccessor! acc) {
+       }
 
-               public virtual void visit_begin_signal (Signal! sig) {
-               }
+       /**
+        * Visit operation called at beginning of signals.
+        *
+        * @param sig a signal
+        */
+       public virtual void visit_begin_signal (Signal! sig) {
+       }
 
-               public virtual void visit_end_signal (Signal! sig) {
-               }
+       /**
+        * Visit operation called at end of signals.
+        *
+        * @param sig a signal
+        */
+       public virtual void visit_end_signal (Signal! sig) {
+       }
 
-               public virtual void visit_begin_constructor (Constructor! c) {
-               }
+       /**
+        * Visit operation called at beginning of constructors.
+        *
+        * @param c a constructor
+        */
+       public virtual void visit_begin_constructor (Constructor! c) {
+       }
 
-               public virtual void visit_end_constructor (Constructor! c) {
-               }
+       /**
+        * Visit operation called at end of constructors.
+        *
+        * @param c a constructor
+        */
+       public virtual void visit_end_constructor (Constructor! c) {
+       }
 
-               public virtual void visit_begin_destructor (Destructor! d) {
-               }
+       /**
+        * Visit operation called at beginning of destructors.
+        *
+        * @param d a destructor
+        */
+       public virtual void visit_begin_destructor (Destructor! d) {
+       }
 
-               public virtual void visit_end_destructor (Destructor! d) {
-               }
+       /**
+        * Visit operation called at end of destructors.
+        *
+        * @param d a destructor
+        */
+       public virtual void visit_end_destructor (Destructor! d) {
+       }
 
-               public virtual void visit_named_argument (NamedArgument! n) {
-               }
+       /**
+        * Visit operation called for named arguments.
+        *
+        * @param n a named argument
+        */
+       public virtual void visit_named_argument (NamedArgument! n) {
+       }
 
-               public virtual void visit_type_parameter (TypeParameter! p) {
-               }
+       /**
+        * Visit operation called for type parameters.
+        *
+        * @param p a type parameter
+        */
+       public virtual void visit_type_parameter (TypeParameter! p) {
+       }
 
-               public virtual void visit_namespace_reference (NamespaceReference! ns) {
-               }
+       /**
+        * Visit operation called for namespace references.
+        *
+        * @param ns a namespace reference
+        */
+       public virtual void visit_namespace_reference (NamespaceReference! ns) {
+       }
 
-               public virtual void visit_type_reference (TypeReference! type) {
-               }
+       /**
+        * Visit operation called for type references.
+        *
+        * @param type a type reference
+        */
+       public virtual void visit_type_reference (TypeReference! type) {
+       }
 
-               public virtual void visit_begin_block (Block! b) {
-               }
+       /**
+        * Visit operation called at beginning of blocks.
+        *
+        * @param b a block
+        */
+       public virtual void visit_begin_block (Block! b) {
+       }
 
-               public virtual void visit_end_block (Block! b) {
-               }
+       /**
+        * Visit operation called at end of blocks.
+        *
+        * @param b a block
+        */
+       public virtual void visit_end_block (Block! b) {
+       }
 
-               public virtual void visit_empty_statement (EmptyStatement! stmt) {
-               }
+       /**
+        * Visit operation called for empty statements.
+        *
+        * @param stmt an empty statement
+        */
+       public virtual void visit_empty_statement (EmptyStatement! stmt) {
+       }
 
-               public virtual void visit_declaration_statement (DeclarationStatement! stmt) {
-               }
+       /**
+        * Visit operation called for declaration statements.
+        *
+        * @param stmt a declaration statement
+        */
+       public virtual void visit_declaration_statement (DeclarationStatement! stmt) {
+       }
 
-               public virtual void visit_local_variable_declaration (LocalVariableDeclaration! decl) {
-               }
+       /**
+        * Visit operation called for local variable declarations.
+        *
+        * @param decl a local variable declaration
+        */
+       public virtual void visit_local_variable_declaration (LocalVariableDeclaration! decl) {
+       }
 
-               public virtual void visit_variable_declarator (VariableDeclarator! decl) {
-               }
+       /**
+        * Visit operation called for variable declarators.
+        *
+        * @param decl a variable declarator
+        */
+       public virtual void visit_variable_declarator (VariableDeclarator! decl) {
+       }
 
-               public virtual void visit_initializer_list (InitializerList! list) {
-               }
+       /**
+        * Visit operation called for initializer lists
+        *
+        * @param list an initializer list
+        */
+       public virtual void visit_initializer_list (InitializerList! list) {
+       }
 
-               public virtual void visit_expression_statement (ExpressionStatement! stmt) {
-               }
+       /**
+        * Visit operation called for expression statements.
+        *
+        * @param stmt an expression statement
+        */
+       public virtual void visit_expression_statement (ExpressionStatement! stmt) {
+       }
 
-               public virtual void visit_if_statement (IfStatement! stmt) {
-               }
+       /**
+        * Visit operation called for if statements.
+        *
+        * @param stmt an if statement
+        */
+       public virtual void visit_if_statement (IfStatement! stmt) {
+       }
 
-               public virtual void visit_while_statement (WhileStatement! stmt) {
-               }
+       /**
+        * Visit operation called for while statements.
+        *
+        * @param stmt an while statement
+        */
+       public virtual void visit_while_statement (WhileStatement! stmt) {
+       }
 
-               public virtual void visit_for_statement (ForStatement! stmt) {
-               }
+       /**
+        * Visit operation called for for statements.
+        *
+        * @param stmt a for statement
+        */
+       public virtual void visit_for_statement (ForStatement! stmt) {
+       }
 
-               public virtual void visit_begin_foreach_statement (ForeachStatement! stmt) {
-               }
+       /**
+        * Visit operation called at beginning of foreach statements.
+        *
+        * @param stmt a foreach statement
+        */
+       public virtual void visit_begin_foreach_statement (ForeachStatement! stmt) {
+       }
 
-               public virtual void visit_end_foreach_statement (ForeachStatement! stmt) {
-               }
+       /**
+        * Visit operation called at end of foreach statements.
+        *
+        * @param stmt a foreach statement
+        */
+       public virtual void visit_end_foreach_statement (ForeachStatement! stmt) {
+       }
 
-               public virtual void visit_break_statement (BreakStatement! stmt) {
-               }
+       /**
+        * Visit operation called for break statements.
+        *
+        * @param stmt a break statement
+        */
+       public virtual void visit_break_statement (BreakStatement! stmt) {
+       }
 
-               public virtual void visit_continue_statement (ContinueStatement! stmt) {
-               }
+       /**
+        * Visit operation called for continue statements.
+        *
+        * @param stmt a continue statement
+        */
+       public virtual void visit_continue_statement (ContinueStatement! stmt) {
+       }
 
-               public virtual void visit_return_statement (ReturnStatement! stmt) {
-               }
+       /**
+        * Visit operation called for return statements.
+        *
+        * @param stmt a return statement
+        */
+       public virtual void visit_return_statement (ReturnStatement! stmt) {
+       }
 
-               public virtual void visit_boolean_literal (BooleanLiteral! expr) {
-               }
+       /**
+        * Visit operation called for boolean literals.
+        *
+        * @param lit a boolean literal
+        */
+       public virtual void visit_boolean_literal (BooleanLiteral! lit) {
+       }
 
-               public virtual void visit_character_literal (CharacterLiteral! expr) {
-               }
+       /**
+        * Visit operation called for character literals.
+        *
+        * @param lit a character literal
+        */
+       public virtual void visit_character_literal (CharacterLiteral! lit) {
+       }
 
-               public virtual void visit_integer_literal (IntegerLiteral! expr) {
-               }
+       /**
+        * Visit operation called for integer literals.
+        *
+        * @param lit an integer literal
+        */
+       public virtual void visit_integer_literal (IntegerLiteral! lit) {
+       }
 
-               public virtual void visit_real_literal (RealLiteral! expr) {
-               }
+       /**
+        * Visit operation called for real literals.
+        *
+        * @param lit a real literal
+        */
+       public virtual void visit_real_literal (RealLiteral! lit) {
+       }
 
-               public virtual void visit_string_literal (StringLiteral! expr) {
-               }
+       /**
+        * Visit operation called for string literals.
+        *
+        * @param lit a string literal
+        */
+       public virtual void visit_string_literal (StringLiteral! lit) {
+       }
 
-               public virtual void visit_null_literal (NullLiteral! expr) {
-               }
+       /**
+        * Visit operation called for null literals.
+        *
+        * @param lit a null literal
+        */
+       public virtual void visit_null_literal (NullLiteral! lit) {
+       }
 
-               public virtual void visit_literal_expression (LiteralExpression! expr) {
-               }
+       /**
+        * Visit operation called for literal expressions.
+        *
+        * @param expr a literal expression
+        */
+       public virtual void visit_literal_expression (LiteralExpression! expr) {
+       }
 
-               public virtual void visit_simple_name (SimpleName! expr) {
-               }
+       /**
+        * Visit operation called for simple names.
+        *
+        * @param expr a simple name
+        */
+       public virtual void visit_simple_name (SimpleName! expr) {
+       }
 
-               public virtual void visit_parenthesized_expression (ParenthesizedExpression! expr) {
-               }
+       /**
+        * Visit operation called for parenthesized expressions.
+        *
+        * @param expr a parenthesized expression
+        */
+       public virtual void visit_parenthesized_expression (ParenthesizedExpression! expr) {
+       }
 
-               public virtual void visit_member_access (MemberAccess! expr) {
-               }
+       /**
+        * Visit operation called for member access expressions.
+        *
+        * @param expr a member access expression
+        */
+       public virtual void visit_member_access (MemberAccess! expr) {
+       }
 
-               public virtual void visit_begin_invocation_expression (InvocationExpression! expr) {
-               }
+       /**
+        * Visit operation called at beginning of invocation expressions.
+        *
+        * @param expr an invocation expression
+        */
+       public virtual void visit_begin_invocation_expression (InvocationExpression! expr) {
+       }
 
-               public virtual void visit_end_invocation_expression (InvocationExpression! expr) {
-               }
+       /**
+        * Visit operation called at end of invocation expressions.
+        *
+        * @param expr an invocation expression
+        */
+       public virtual void visit_end_invocation_expression (InvocationExpression! expr) {
+       }
 
-               public virtual void visit_postfix_expression (PostfixExpression! expr) {
-               }
+       /**
+        * Visit operation called for postfix expressions.
+        *
+        * @param expr a postfix expression
+        */
+       public virtual void visit_postfix_expression (PostfixExpression! expr) {
+       }
 
-               public virtual void visit_object_creation_expression (ObjectCreationExpression! expr) {
-               }
+       /**
+        * Visit operation called for object creation expressions.
+        *
+        * @param expr an object creation expression
+        */
+       public virtual void visit_object_creation_expression (ObjectCreationExpression! expr) {
+       }
 
-               public virtual void visit_typeof_expression (TypeofExpression! expr) {
-               }
+       /**
+        * Visit operation called for typeof expressions.
+        *
+        * @param expr a typeof expression
+        */
+       public virtual void visit_typeof_expression (TypeofExpression! expr) {
+       }
 
-               public virtual void visit_unary_expression (UnaryExpression! expr) {
-               }
+       /**
+        * Visit operation called for unary expressions.
+        *
+        * @param expr an unary expression
+        */
+       public virtual void visit_unary_expression (UnaryExpression! expr) {
+       }
 
-               public virtual void visit_cast_expression (CastExpression! expr) {
-               }
+       /**
+        * Visit operation called for call expressions.
+        *
+        * @param expr a call expression
+        */
+       public virtual void visit_cast_expression (CastExpression! expr) {
+       }
 
-               public virtual void visit_binary_expression (BinaryExpression! expr) {
-               }
+       /**
+        * Visit operation called for binary expressions.
+        *
+        * @param expr a binary expression
+        */
+       public virtual void visit_binary_expression (BinaryExpression! expr) {
+       }
 
-               public virtual void visit_type_check (TypeCheck! expr) {
-               }
+       /**
+        * Visit operation called for type checks.
+        *
+        * @param expr a type check expression
+        */
+       public virtual void visit_type_check (TypeCheck! expr) {
+       }
 
-               public virtual void visit_conditional_expression (ConditionalExpression! expr) {
-               }
+       /**
+        * Visit operation called for conditional expressions.
+        *
+        * @param expr a conditional expression
+        */
+       public virtual void visit_conditional_expression (ConditionalExpression! expr) {
+       }
 
-               public virtual void visit_begin_lambda_expression (LambdaExpression! expr) {
-               }
+       /**
+        * Visit operation called at beginning of lambda expressions.
+        *
+        * @param expr a lambda expression
+        */
+       public virtual void visit_begin_lambda_expression (LambdaExpression! expr) {
+       }
 
-               public virtual void visit_end_lambda_expression (LambdaExpression! expr) {
-               }
+       /**
+        * Visit operation called at end of lambda expressions.
+        *
+        * @param expr a lambda expression
+        */
+       public virtual void visit_end_lambda_expression (LambdaExpression! expr) {
+       }
 
-               public virtual void visit_assignment (Assignment! a) {
-               }
+       /**
+        * Visit operation called for assignments.
+        *
+        * @param a an assignment
+        */
+       public virtual void visit_assignment (Assignment! a) {
+       }
 
-               public virtual void visit_end_full_expression (Expression! expr) {
-               }
+       /**
+        * Visit operation called at end of full expressions.
+        *
+        * @param expr a full expression
+        */
+       public virtual void visit_end_full_expression (Expression! expr) {
        }
 }