Remove cast from AstNodeImpl._becomeParentOf

pkg/analyzer/lib/dart/ast/ast.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Defines the AST model. The AST (Abstract Syntax Tree) model describes the
  * syntactic (as opposed to semantic) structure of Dart code. The semantic
  * structure of the code is modeled by the
  * [element model](../element/element.dart).
  *
@@ skipping 107 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Annotation extends AstNode {
   /**
    * Initialize a newly created annotation. Both the [period] and the
    * [constructorName] can be `null` if the annotation is not referencing a
    * named constructor. The [arguments] can be `null` if the annotation is not
    * referencing a constructor.
    */
-  factory Annotation(
-      Token atSign,
-      Identifier name,
-      Token period,
-      SimpleIdentifier constructorName,
-      ArgumentList arguments) = AnnotationImpl;
+  factory Annotation(Token atSign, Identifier name, Token period,
+          SimpleIdentifier constructorName, ArgumentList arguments) =>
+      new AnnotationImpl(atSign, name, period, constructorName, arguments);
 
   /**
    * Return the arguments to the constructor being invoked, or `null` if this
    * annotation is not the invocation of a constructor.
    */
   ArgumentList get arguments;
 
   /**
    * Set the arguments to the constructor being invoked to the given [arguments].
    */
@@ skipping 137 matching lines @@
  *
  *    asExpression ::=
  *        [Expression] 'as' [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AsExpression extends Expression {
   /**
    * Initialize a newly created as expression.
    */
-  factory AsExpression(Expression expression, Token asOperator, TypeName type) =
-      AsExpressionImpl;
+  factory AsExpression(
+          Expression expression, Token asOperator, TypeName type) =>
+      new AsExpressionImpl(expression, asOperator, type);
 
   /**
    * Return the 'as' operator.
    */
   Token get asOperator;
 
   /**
    * Set the 'as' operator to the given [token].
    */
   void set asOperator(Token token);
@@ skipping 27 matching lines @@
  *        'assert' '(' [Expression] ')' ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AssertStatement extends Statement {
   /**
    * Initialize a newly created assert statement. The [comma] and [message] can
    * be `null` if there is no message.
    */
   factory AssertStatement(
-      Token assertKeyword,
-      Token leftParenthesis,
-      Expression condition,
-      Token comma,
-      Expression message,
-      Token rightParenthesis,
-      Token semicolon) = AssertStatementImpl;
+          Token assertKeyword,
+          Token leftParenthesis,
+          Expression condition,
+          Token comma,
+          Expression message,
+          Token rightParenthesis,
+          Token semicolon) =>
+      new AssertStatementImpl(assertKeyword, leftParenthesis, condition, comma,
+          message, rightParenthesis, semicolon);
 
   /**
    * Return the token representing the 'assert' keyword.
    */
   Token get assertKeyword;
 
   /**
    * Set the token representing the 'assert' keyword to the given [token].
    */
   void set assertKeyword(Token token);
@@ skipping 69 matching lines @@
  *    assignmentExpression ::=
  *        [Expression] operator [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AssignmentExpression extends Expression {
   /**
    * Initialize a newly created assignment expression.
    */
   factory AssignmentExpression(
-          Expression leftHandSide, Token operator, Expression rightHandSide) =
-      AssignmentExpressionImpl;
+          Expression leftHandSide, Token operator, Expression rightHandSide) =>
+      new AssignmentExpressionImpl(leftHandSide, operator, rightHandSide);
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement;
 
@@ skipping 407 matching lines @@
  *
  *    awaitExpression ::=
  *        'await' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AwaitExpression extends Expression {
   /**
    * Initialize a newly created await expression.
    */
-  factory AwaitExpression(Token awaitKeyword, Expression expression) =
-      AwaitExpressionImpl;
+  factory AwaitExpression(Token awaitKeyword, Expression expression) =>
+      new AwaitExpressionImpl(awaitKeyword, expression);
 
   /**
    * Return the 'await' keyword.
    */
   Token get awaitKeyword;
 
   /**
    * Set the 'await' keyword to the given [token].
    */
   void set awaitKeyword(Token token);
@@ skipping 15 matching lines @@
  *    binaryExpression ::=
  *        [Expression] [Token] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BinaryExpression extends Expression {
   /**
    * Initialize a newly created binary expression.
    */
   factory BinaryExpression(
-          Expression leftOperand, Token operator, Expression rightOperand) =
-      BinaryExpressionImpl;
+          Expression leftOperand, Token operator, Expression rightOperand) =>
+      new BinaryExpressionImpl(leftOperand, operator, rightOperand);
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement;
 
@@ skipping 64 matching lines @@
  *    block ::=
  *        '{' statement* '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Block extends Statement {
   /**
    * Initialize a newly created block of code.
    */
   factory Block(
-          Token leftBracket, List<Statement> statements, Token rightBracket) =
-      BlockImpl;
+          Token leftBracket, List<Statement> statements, Token rightBracket) =>
+      new BlockImpl(leftBracket, statements, rightBracket);
 
   /**
    * Return the left curly bracket.
    */
   Token get leftBracket;
 
   /**
    * Set the left curly bracket to the given [token].
    */
   void set leftBracket(Token token);
@@ skipping 22 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BlockFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if there is no keyword specified
    * for the block. The [star] can be `null` if there is no star following the
    * keyword (and must be `null` if there is no keyword).
    */
-  factory BlockFunctionBody(Token keyword, Token star, Block block) =
-      BlockFunctionBodyImpl;
+  factory BlockFunctionBody(Token keyword, Token star, Block block) =>
+      new BlockFunctionBodyImpl(keyword, star, block);
 
   /**
    * Return the block representing the body of the function.
    */
   Block get block;
 
   /**
    * Set the block representing the body of the function to the given [block].
    */
   void set block(Block block);
@@ skipping 46 matching lines @@
  *        'break' [SimpleIdentifier]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BreakStatement extends Statement {
   /**
    * Initialize a newly created break statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
   factory BreakStatement(
-          Token breakKeyword, SimpleIdentifier label, Token semicolon) =
-      BreakStatementImpl;
+          Token breakKeyword, SimpleIdentifier label, Token semicolon) =>
+      new BreakStatementImpl(breakKeyword, label, semicolon);
 
   /**
    * Return the token representing the 'break' keyword.
    */
   Token get breakKeyword;
 
   /**
    * Set the token representing the 'break' keyword to the given [token].
    */
   void set breakKeyword(Token token);
@@ skipping 54 matching lines @@
  *      | identifier
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CascadeExpression extends Expression {
   /**
    * Initialize a newly created cascade expression. The list of
    * [cascadeSections] must contain at least one element.
    */
   factory CascadeExpression(
-          Expression target, List<Expression> cascadeSections) =
-      CascadeExpressionImpl;
+          Expression target, List<Expression> cascadeSections) =>
+      new CascadeExpressionImpl(target, cascadeSections);
 
   /**
    * Return the cascade sections sharing the common target.
    */
   NodeList<Expression> get cascadeSections;
 
   /**
    * Return the target of the cascade sections.
    */
   Expression get target;
@@ skipping 17 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CatchClause extends AstNode {
   /**
    * Initialize a newly created catch clause. The [onKeyword] and
    * [exceptionType] can be `null` if the clause will catch all exceptions. The
    * [comma] and [stackTraceParameter] can be `null` if the stack trace
    * parameter is not defined.
    */
   factory CatchClause(
-      Token onKeyword,
-      TypeName exceptionType,
-      Token catchKeyword,
-      Token leftParenthesis,
-      SimpleIdentifier exceptionParameter,
-      Token comma,
-      SimpleIdentifier stackTraceParameter,
-      Token rightParenthesis,
-      Block body) = CatchClauseImpl;
+          Token onKeyword,
+          TypeName exceptionType,
+          Token catchKeyword,
+          Token leftParenthesis,
+          SimpleIdentifier exceptionParameter,
+          Token comma,
+          SimpleIdentifier stackTraceParameter,
+          Token rightParenthesis,
+          Block body) =>
+      new CatchClauseImpl(
+          onKeyword,
+          exceptionType,
+          catchKeyword,
+          leftParenthesis,
+          exceptionParameter,
+          comma,
+          stackTraceParameter,
+          rightParenthesis,
+          body);
 
   /**
    * Return the body of the catch block.
    */
   Block get body;
 
   /**
    * Set the body of the catch block to the given [block].
    */
   void set body(Block block);
@@ skipping 105 matching lines @@
    * Initialize a newly created class declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the class does not have the
    * corresponding attribute. The [abstractKeyword] can be `null` if the class
    * is not abstract. The [typeParameters] can be `null` if the class does not
    * have any type parameters. Any or all of the [extendsClause], [withClause],
    * and [implementsClause] can be `null` if the class does not have the
    * corresponding clause. The list of [members] can be `null` if the class does
    * not have any members.
    */
   factory ClassDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      Token abstractKeyword,
-      Token classKeyword,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      ExtendsClause extendsClause,
-      WithClause withClause,
-      ImplementsClause implementsClause,
-      Token leftBracket,
-      List<ClassMember> members,
-      Token rightBracket) = ClassDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token abstractKeyword,
+          Token classKeyword,
+          SimpleIdentifier name,
+          TypeParameterList typeParameters,
+          ExtendsClause extendsClause,
+          WithClause withClause,
+          ImplementsClause implementsClause,
+          Token leftBracket,
+          List<ClassMember> members,
+          Token rightBracket) =>
+      new ClassDeclarationImpl(
+          comment,
+          metadata,
+          abstractKeyword,
+          classKeyword,
+          name,
+          typeParameters,
+          extendsClause,
+          withClause,
+          implementsClause,
+          leftBracket,
+          members,
+          rightBracket);
 
   /**
    * Return the 'abstract' keyword, or `null` if the keyword was absent.
    */
   Token get abstractKeyword;
 
   /**
    * Set the 'abstract' keyword to the given [token].
    */
   void set abstractKeyword(Token token);
@@ skipping 137 matching lines @@
 abstract class ClassTypeAlias extends TypeAlias {
   /**
    * Initialize a newly created class type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the class type alias does not
    * have the corresponding attribute. The [typeParameters] can be `null` if the
    * class does not have any type parameters. The [abstractKeyword] can be
    * `null` if the class is not abstract. The [implementsClause] can be `null`
    * if the class does not implement any interfaces.
    */
   factory ClassTypeAlias(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      Token equals,
-      Token abstractKeyword,
-      TypeName superclass,
-      WithClause withClause,
-      ImplementsClause implementsClause,
-      Token semicolon) = ClassTypeAliasImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token keyword,
+          SimpleIdentifier name,
+          TypeParameterList typeParameters,
+          Token equals,
+          Token abstractKeyword,
+          TypeName superclass,
+          WithClause withClause,
+          ImplementsClause implementsClause,
+          Token semicolon) =>
+      new ClassTypeAliasImpl(
+          comment,
+          metadata,
+          keyword,
+          name,
+          typeParameters,
+          equals,
+          abstractKeyword,
+          superclass,
+          withClause,
+          implementsClause,
+          semicolon);
 
   /**
    * Return the token for the 'abstract' keyword, or `null` if this is not
    * defining an abstract class.
    */
   Token get abstractKeyword;
 
   /**
    * Set the token for the 'abstract' keyword to the given [token].
    */
@@ skipping 170 matching lines @@
  *    commentReference ::=
  *        '[' 'new'? [Identifier] ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class CommentReference extends AstNode {
   /**
    * Initialize a newly created reference to a Dart element. The [newKeyword]
    * can be `null` if the reference is not to a constructor.
    */
-  factory CommentReference(Token newKeyword, Identifier identifier) =
-      CommentReferenceImpl;
+  factory CommentReference(Token newKeyword, Identifier identifier) =>
+      new CommentReferenceImpl(newKeyword, identifier);
 
   /**
    * Return the identifier being referenced.
    */
   Identifier get identifier;
 
   /**
    * Set the identifier being referenced to the given [identifier].
    */
   void set identifier(Identifier identifier);
@@ skipping 37 matching lines @@
  */
 abstract class CompilationUnit extends AstNode {
   /**
    * Initialize a newly created compilation unit to have the given directives
    * and declarations. The [scriptTag] can be `null` if there is no script tag
    * in the compilation unit. The list of [directives] can be `null` if there
    * are no directives in the compilation unit. The list of [declarations] can
    * be `null` if there are no declarations in the compilation unit.
    */
   factory CompilationUnit(
-      Token beginToken,
-      ScriptTag scriptTag,
-      List<Directive> directives,
-      List<CompilationUnitMember> declarations,
-      Token endToken) = CompilationUnitImpl;
+          Token beginToken,
+          ScriptTag scriptTag,
+          List<Directive> directives,
+          List<CompilationUnitMember> declarations,
+          Token endToken) =>
+      new CompilationUnitImpl(
+          beginToken, scriptTag, directives, declarations, endToken);
 
   /**
    * Set the first token included in this node's source range to the given
    * [token].
    */
   void set beginToken(Token token);
 
   /**
    * Return the declarations contained in this compilation unit.
    */
@@ skipping 72 matching lines @@
  *
  *    conditionalExpression ::=
  *        [Expression] '?' [Expression] ':' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConditionalExpression extends Expression {
   /**
    * Initialize a newly created conditional expression.
    */
-  factory ConditionalExpression(
-      Expression condition,
-      Token question,
-      Expression thenExpression,
-      Token colon,
-      Expression elseExpression) = ConditionalExpressionImpl;
+  factory ConditionalExpression(Expression condition, Token question,
+          Expression thenExpression, Token colon, Expression elseExpression) =>
+      new ConditionalExpressionImpl(
+          condition, question, thenExpression, colon, elseExpression);
 
   /**
    * Return the token used to separate the then expression from the else
    * expression.
    */
   Token get colon;
 
   /**
    * Set the token used to separate the then expression from the else expression
    * to the given [token].
@@ skipping 60 matching lines @@
  *    dottedName ::=
  *        identifier ('.' identifier)*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Configuration extends AstNode {
   /**
    * Initialize a newly created configuration.
    */
   factory Configuration(
-      Token ifKeyword,
-      Token leftParenthesis,
-      DottedName name,
-      Token equalToken,
-      StringLiteral value,
-      Token rightParenthesis,
-      StringLiteral libraryUri) = ConfigurationImpl;
+          Token ifKeyword,
+          Token leftParenthesis,
+          DottedName name,
+          Token equalToken,
+          StringLiteral value,
+          Token rightParenthesis,
+          StringLiteral libraryUri) =>
+      new ConfigurationImpl(ifKeyword, leftParenthesis, name, equalToken, value,
+          rightParenthesis, libraryUri);
 
   /**
    * Return the token for the equal operator, or `null` if the condition does
    * not include an equality test.
    */
   Token get equalToken;
 
   /**
    * Set the token for the equal operator to the given [token].
    */
@@ skipping 99 matching lines @@
    * be `null` if the constructor is not a factory. The [period] and [name] can
    * both be `null` if the constructor is not a named constructor. The
    * [separator] can be `null` if the constructor does not have any initializers
    * and does not redirect to a different constructor. The list of
    * [initializers] can be `null` if the constructor does not have any
    * initializers. The [redirectedConstructor] can be `null` if the constructor
    * does not redirect to a different constructor. The [body] can be `null` if
    * the constructor does not have a body.
    */
   factory ConstructorDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      Token externalKeyword,
-      Token constKeyword,
-      Token factoryKeyword,
-      Identifier returnType,
-      Token period,
-      SimpleIdentifier name,
-      FormalParameterList parameters,
-      Token separator,
-      List<ConstructorInitializer> initializers,
-      ConstructorName redirectedConstructor,
-      FunctionBody body) = ConstructorDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token externalKeyword,
+          Token constKeyword,
+          Token factoryKeyword,
+          Identifier returnType,
+          Token period,
+          SimpleIdentifier name,
+          FormalParameterList parameters,
+          Token separator,
+          List<ConstructorInitializer> initializers,
+          ConstructorName redirectedConstructor,
+          FunctionBody body) =>
+      new ConstructorDeclarationImpl(
+          comment,
+          metadata,
+          externalKeyword,
+          constKeyword,
+          factoryKeyword,
+          returnType,
+          period,
+          name,
+          parameters,
+          separator,
+          initializers,
+          redirectedConstructor,
+          body);
 
   /**
    * Return the body of the constructor, or `null` if the constructor does not
    * have a body.
    */
   FunctionBody get body;
 
   /**
    * Set the body of the constructor to the given [functionBody].
    */
@@ skipping 123 matching lines @@
  *        ('this' '.')? [SimpleIdentifier] '=' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorFieldInitializer extends ConstructorInitializer {
   /**
    * Initialize a newly created field initializer to initialize the field with
    * the given name to the value of the given expression. The [thisKeyword] and
    * [period] can be `null` if the 'this' keyword was not specified.
    */
-  factory ConstructorFieldInitializer(
-      Token thisKeyword,
-      Token period,
-      SimpleIdentifier fieldName,
-      Token equals,
-      Expression expression) = ConstructorFieldInitializerImpl;
+  factory ConstructorFieldInitializer(Token thisKeyword, Token period,
+          SimpleIdentifier fieldName, Token equals, Expression expression) =>
+      new ConstructorFieldInitializerImpl(
+          thisKeyword, period, fieldName, equals, expression);
 
   /**
    * Return the token for the equal sign between the field name and the
    * expression.
    */
   Token get equals;
 
   /**
    * Set the token for the equal sign between the field name and the
    * expression to the given [token].
@@ skipping 63 matching lines @@
  *    constructorName ::=
  *        type ('.' identifier)?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorName extends AstNode {
   /**
    * Initialize a newly created constructor name. The [period] and [name] can be
    * `null` if the constructor being named is the unnamed constructor.
    */
-  factory ConstructorName(TypeName type, Token period, SimpleIdentifier name) =
-      ConstructorNameImpl;
+  factory ConstructorName(TypeName type, Token period, SimpleIdentifier name) =>
+      new ConstructorNameImpl(type, period, name);
 
   /**
    * Return the name of the constructor, or `null` if the specified constructor
    * is the unnamed constructor.
    */
   SimpleIdentifier get name;
 
   /**
    * Set the name of the constructor to the given [name].
    */
@@ skipping 42 matching lines @@
  *        'continue' [SimpleIdentifier]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ContinueStatement extends Statement {
   /**
    * Initialize a newly created continue statement. The [label] can be `null` if
    * there is no label associated with the statement.
    */
   factory ContinueStatement(
-          Token continueKeyword, SimpleIdentifier label, Token semicolon) =
-      ContinueStatementImpl;
+          Token continueKeyword, SimpleIdentifier label, Token semicolon) =>
+      new ContinueStatementImpl(continueKeyword, label, semicolon);
 
   /**
    * Return the token representing the 'continue' keyword.
    */
   Token get continueKeyword;
 
   /**
    * Set the token representing the 'continue' keyword to the given [token].
    */
   void set continueKeyword(Token token);
@@ skipping 59 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DeclaredIdentifier extends Declaration {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [keyword] can be `null` if a type name is
    * given. The [type] must be `null` if the keyword is 'var'.
    */
-  factory DeclaredIdentifier(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      TypeName type,
-      SimpleIdentifier identifier) = DeclaredIdentifierImpl;
+  factory DeclaredIdentifier(Comment comment, List<Annotation> metadata,
+          Token keyword, TypeName type, SimpleIdentifier identifier) =>
+      new DeclaredIdentifierImpl(comment, metadata, keyword, type, identifier);
 
   @override
   LocalVariableElement get element;
 
   /**
    * Return the name of the variable being declared.
    */
   SimpleIdentifier get identifier;
 
   /**
@@ skipping 48 matching lines @@
  *    defaultNamedParameter ::=
  *        [NormalFormalParameter] (':' [Expression])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DefaultFormalParameter extends FormalParameter {
   /**
    * Initialize a newly created default formal parameter. The [separator] and
    * [defaultValue] can be `null` if there is no default value.
    */
-  factory DefaultFormalParameter(
-      NormalFormalParameter parameter,
-      ParameterKind kind,
-      Token separator,
-      Expression defaultValue) = DefaultFormalParameterImpl;
+  factory DefaultFormalParameter(NormalFormalParameter parameter,
+          ParameterKind kind, Token separator, Expression defaultValue) =>
+      new DefaultFormalParameterImpl(parameter, kind, separator, defaultValue);
 
   /**
    * Return the expression computing the default value for the parameter, or
    * `null` if there is no default value.
    */
   Expression get defaultValue;
 
   /**
    * Set the expression computing the default value for the parameter to the
    * given [expression].
@@ skipping 66 matching lines @@
  *    doStatement ::=
  *        'do' [Statement] 'while' '(' [Expression] ')' ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DoStatement extends Statement {
   /**
    * Initialize a newly created do loop.
    */
   factory DoStatement(
-      Token doKeyword,
-      Statement body,
-      Token whileKeyword,
-      Token leftParenthesis,
-      Expression condition,
-      Token rightParenthesis,
-      Token semicolon) = DoStatementImpl;
+          Token doKeyword,
+          Statement body,
+          Token whileKeyword,
+          Token leftParenthesis,
+          Expression condition,
+          Token rightParenthesis,
+          Token semicolon) =>
+      new DoStatementImpl(doKeyword, body, whileKeyword, leftParenthesis,
+          condition, rightParenthesis, semicolon);
 
   /**
    * Return the body of the loop.
    */
   Statement get body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement);
@@ skipping 178 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EnumConstantDeclaration extends Declaration {
   /**
    * Initialize a newly created enum constant declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the constant does not have the
    * corresponding attribute. (Technically, enum constants cannot have metadata,
    * but we allow it for consistency.)
    */
   factory EnumConstantDeclaration(
-          Comment comment, List<Annotation> metadata, SimpleIdentifier name) =
-      EnumConstantDeclarationImpl;
+          Comment comment, List<Annotation> metadata, SimpleIdentifier name) =>
+      new EnumConstantDeclarationImpl(comment, metadata, name);
 
   /**
    * Return the name of the constant.
    */
   SimpleIdentifier get name;
 
   /**
    * Set the name of the constant to the given [name].
    */
   void set name(SimpleIdentifier name);
 }
 
 /**
  * The declaration of an enumeration.
  *
  *    enumType ::=
  *        metadata 'enum' [SimpleIdentifier] '{' [SimpleIdentifier] (',' [SimpleIdentifier])* (',')? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EnumDeclaration extends NamedCompilationUnitMember {
   /**
    * Initialize a newly created enumeration declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The list of [constants] must contain at least one
    * value.
    */
   factory EnumDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      Token enumKeyword,
-      SimpleIdentifier name,
-      Token leftBracket,
-      List<EnumConstantDeclaration> constants,
-      Token rightBracket) = EnumDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token enumKeyword,
+          SimpleIdentifier name,
+          Token leftBracket,
+          List<EnumConstantDeclaration> constants,
+          Token rightBracket) =>
+      new EnumDeclarationImpl(comment, metadata, enumKeyword, name, leftBracket,
+          constants, rightBracket);
 
   /**
    * Return the enumeration constants being declared.
    */
   NodeList<EnumConstantDeclaration> get constants;
 
   @override
   ClassElement get element;
 
   /**
@@ skipping 36 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExportDirective extends NamespaceDirective {
   /**
    * Initialize a newly created export directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute. The list of [combinators] can be `null` if there
    * are no combinators.
    */
   factory ExportDirective(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      StringLiteral libraryUri,
-      List<Configuration> configurations,
-      List<Combinator> combinators,
-      Token semicolon) = ExportDirectiveImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token keyword,
+          StringLiteral libraryUri,
+          List<Configuration> configurations,
+          List<Combinator> combinators,
+          Token semicolon) =>
+      new ExportDirectiveImpl(comment, metadata, keyword, libraryUri,
+          configurations, combinators, semicolon);
 }
 
 /**
  * A node that represents an expression.
  *
  *    expression ::=
  *        [AssignmentExpression]
  *      | [ConditionalExpression] cascadeSection*
  *      | [ThrowExpression]
  *
@@ skipping 98 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExpressionFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body consisting of a block of
    * statements. The [keyword] can be `null` if the function body is not an
    * async function body.
    */
   factory ExpressionFunctionBody(Token keyword, Token functionDefinition,
-      Expression expression, Token semicolon) = ExpressionFunctionBodyImpl;
+          Expression expression, Token semicolon) =>
+      new ExpressionFunctionBodyImpl(
+          keyword, functionDefinition, expression, semicolon);
 
   /**
    * Return the expression representing the body of the function.
    */
   Expression get expression;
 
   /**
    * Set the expression representing the body of the function to the given
    * [expression].
    */
@@ skipping 32 matching lines @@
  *
  *    expressionStatement ::=
  *        [Expression]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExpressionStatement extends Statement {
   /**
    * Initialize a newly created expression statement.
    */
-  factory ExpressionStatement(Expression expression, Token semicolon) =
-      ExpressionStatementImpl;
+  factory ExpressionStatement(Expression expression, Token semicolon) =>
+      new ExpressionStatementImpl(expression, semicolon);
 
   /**
    * Return the expression that comprises the statement.
    */
   Expression get expression;
 
   /**
    * Set the expression that comprises the statement to the given [expression].
    */
   void set expression(Expression expression);
@@ skipping 15 matching lines @@
  *
  *    extendsClause ::=
  *        'extends' [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ExtendsClause extends AstNode {
   /**
    * Initialize a newly created extends clause.
    */
-  factory ExtendsClause(Token extendsKeyword, TypeName superclass) =
-      ExtendsClauseImpl;
+  factory ExtendsClause(Token extendsKeyword, TypeName superclass) =>
+      new ExtendsClauseImpl(extendsKeyword, superclass);
 
   /**
    * Return the token representing the 'extends' keyword.
    */
   Token get extendsKeyword;
 
   /**
    * Set the token representing the 'extends' keyword to the given [token].
    */
   void set extendsKeyword(Token token);
@@ skipping 18 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FieldDeclaration extends ClassMember {
   /**
    * Initialize a newly created field declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [staticKeyword] can be `null` if the field is
    * not a static field.
    */
   factory FieldDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      Token staticKeyword,
-      VariableDeclarationList fieldList,
-      Token semicolon) = FieldDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token staticKeyword,
+          VariableDeclarationList fieldList,
+          Token semicolon) =>
+      new FieldDeclarationImpl(
+          comment, metadata, staticKeyword, fieldList, semicolon);
 
   /**
    * Return the fields being declared.
    */
   VariableDeclarationList get fields;
 
   /**
    * Set the fields being declared to the given list of [fields].
    */
   void set fields(VariableDeclarationList fields);
@@ skipping 38 matching lines @@
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if there is a type.
    * The [type] must be `null` if the keyword is 'var'. The [thisKeyword] and
    * [period] can be `null` if the keyword 'this' was not provided.  The
    * [parameters] can be `null` if this is not a function-typed field formal
    * parameter.
    */
   factory FieldFormalParameter(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      TypeName type,
-      Token thisKeyword,
-      Token period,
-      SimpleIdentifier identifier,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters) = FieldFormalParameterImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token keyword,
+          TypeName type,
+          Token thisKeyword,
+          Token period,
+          SimpleIdentifier identifier,
+          TypeParameterList typeParameters,
+          FormalParameterList parameters) =>
+      new FieldFormalParameterImpl(comment, metadata, keyword, type,
+          thisKeyword, period, identifier, typeParameters, parameters);
 
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword,
    * or `null` if no keyword was used.
    */
   Token get keyword;
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to
    * the given [token].
@@ skipping 67 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ForEachStatement extends Statement {
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared internally (in the for-loop part). The [awaitKeyword] can be
    * `null` if this is not an asynchronous for loop.
    */
   factory ForEachStatement.withDeclaration(
-      Token awaitKeyword,
-      Token forKeyword,
-      Token leftParenthesis,
-      DeclaredIdentifier loopVariable,
-      Token inKeyword,
-      Expression iterator,
-      Token rightParenthesis,
-      Statement body) = ForEachStatementImpl.withDeclaration;
+          Token awaitKeyword,
+          Token forKeyword,
+          Token leftParenthesis,
+          DeclaredIdentifier loopVariable,
+          Token inKeyword,
+          Expression iterator,
+          Token rightParenthesis,
+          Statement body) =>
+      new ForEachStatementImpl.withDeclaration(
+          awaitKeyword,
+          forKeyword,
+          leftParenthesis,
+          loopVariable,
+          inKeyword,
+          iterator,
+          rightParenthesis,
+          body);
 
   /**
    * Initialize a newly created for-each statement whose loop control variable
    * is declared outside the for loop. The [awaitKeyword] can be `null` if this
    * is not an asynchronous for loop.
    */
   factory ForEachStatement.withReference(
-      Token awaitKeyword,
-      Token forKeyword,
-      Token leftParenthesis,
-      SimpleIdentifier identifier,
-      Token inKeyword,
-      Expression iterator,
-      Token rightParenthesis,
-      Statement body) = ForEachStatementImpl.withReference;
+          Token awaitKeyword,
+          Token forKeyword,
+          Token leftParenthesis,
+          SimpleIdentifier identifier,
+          Token inKeyword,
+          Expression iterator,
+          Token rightParenthesis,
+          Statement body) =>
+      new ForEachStatementImpl.withReference(
+          awaitKeyword,
+          forKeyword,
+          leftParenthesis,
+          identifier,
+          inKeyword,
+          iterator,
+          rightParenthesis,
+          body);
 
   /**
    * Return the token representing the 'await' keyword, or `null` if there is no
    * 'await' keyword.
    */
   Token get awaitKeyword;
 
   /**
    * Set the token representing the 'await' keyword to the given [token].
    */
@@ skipping 243 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ForStatement extends Statement {
   /**
    * Initialize a newly created for statement. Either the [variableList] or the
    * [initialization] must be `null`. Either the [condition] and the list of
    * [updaters] can be `null` if the loop does not have the corresponding
    * attribute.
    */
   factory ForStatement(
-      Token forKeyword,
-      Token leftParenthesis,
-      VariableDeclarationList variableList,
-      Expression initialization,
-      Token leftSeparator,
-      Expression condition,
-      Token rightSeparator,
-      List<Expression> updaters,
-      Token rightParenthesis,
-      Statement body) = ForStatementImpl;
+          Token forKeyword,
+          Token leftParenthesis,
+          VariableDeclarationList variableList,
+          Expression initialization,
+          Token leftSeparator,
+          Expression condition,
+          Token rightSeparator,
+          List<Expression> updaters,
+          Token rightParenthesis,
+          Statement body) =>
+      new ForStatementImpl(
+          forKeyword,
+          leftParenthesis,
+          variableList,
+          initialization,
+          leftSeparator,
+          condition,
+          rightSeparator,
+          updaters,
+          rightParenthesis,
+          body);
 
   /**
    * Return the body of the loop.
    */
   Statement get body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement);
@@ skipping 170 matching lines @@
 abstract class FunctionDeclaration extends NamedCompilationUnitMember {
   /**
    * Initialize a newly created function declaration. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the
    * function is not an external function. The [returnType] can be `null` if no
    * return type was specified. The [propertyKeyword] can be `null` if the
    * function is neither a getter or a setter.
    */
   factory FunctionDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      Token externalKeyword,
-      TypeName returnType,
-      Token propertyKeyword,
-      SimpleIdentifier name,
-      FunctionExpression functionExpression) = FunctionDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token externalKeyword,
+          TypeName returnType,
+          Token propertyKeyword,
+          SimpleIdentifier name,
+          FunctionExpression functionExpression) =>
+      new FunctionDeclarationImpl(comment, metadata, externalKeyword,
+          returnType, propertyKeyword, name, functionExpression);
 
   @override
   ExecutableElement get element;
 
   /**
    * Return the token representing the 'external' keyword, or `null` if this is
    * not an external function.
    */
   Token get externalKeyword;
 
@@ skipping 76 matching lines @@
  *
  *    functionExpression ::=
  *        [TypeParameterList]? [FormalParameterList] [FunctionBody]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionExpression extends Expression {
   /**
    * Initialize a newly created function declaration.
    */
-  factory FunctionExpression(
-      TypeParameterList typeParameters,
-      FormalParameterList parameters,
-      FunctionBody body) = FunctionExpressionImpl;
+  factory FunctionExpression(TypeParameterList typeParameters,
+          FormalParameterList parameters, FunctionBody body) =>
+      new FunctionExpressionImpl(typeParameters, parameters, body);
 
   /**
    * Return the body of the function, or `null` if this is an external function.
    */
   FunctionBody get body;
 
   /**
    * Set the body of the function to the given [functionBody].
    */
   void set body(FunctionBody functionBody);
@@ skipping 41 matching lines @@
  *
  *    functionExpressionInvocation ::=
  *        [Expression] [TypeArgumentList]? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionExpressionInvocation extends InvocationExpression {
   /**
    * Initialize a newly created function expression invocation.
    */
-  factory FunctionExpressionInvocation(
-      Expression function,
-      TypeArgumentList typeArguments,
-      ArgumentList argumentList) = FunctionExpressionInvocationImpl;
+  factory FunctionExpressionInvocation(Expression function,
+          TypeArgumentList typeArguments, ArgumentList argumentList) =>
+      new FunctionExpressionInvocationImpl(
+          function, typeArguments, argumentList);
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList);
 
   /**
    * Return the best element available for the function being invoked. If
    * resolution was able to find a better element based on type propagation,
    * that element will be returned. Otherwise, the element found using the
@@ skipping 98 matching lines @@
  */
 abstract class FunctionTypeAlias extends TypeAlias {
   /**
    * Initialize a newly created function type alias. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified. The [typeParameters] can be `null` if the function has no
    * type parameters.
    */
   factory FunctionTypeAlias(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      TypeName returnType,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters,
-      Token semicolon) = FunctionTypeAliasImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token keyword,
+          TypeName returnType,
+          SimpleIdentifier name,
+          TypeParameterList typeParameters,
+          FormalParameterList parameters,
+          Token semicolon) =>
+      new FunctionTypeAliasImpl(comment, metadata, keyword, returnType, name,
+          typeParameters, parameters, semicolon);
 
   /**
    * Return the parameters associated with the function type.
    */
   FormalParameterList get parameters;
 
   /**
    * Set the parameters associated with the function type to the given list of
    * [parameters].
    */
@@ skipping 33 matching lines @@
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionTypedFormalParameter extends NormalFormalParameter {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
   factory FunctionTypedFormalParameter(
-      Comment comment,
-      List<Annotation> metadata,
-      TypeName returnType,
-      SimpleIdentifier identifier,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters) = FunctionTypedFormalParameterImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          TypeName returnType,
+          SimpleIdentifier identifier,
+          TypeParameterList typeParameters,
+          FormalParameterList parameters) =>
+      new FunctionTypedFormalParameterImpl(comment, metadata, returnType,
+          identifier, typeParameters, parameters);
 
   /**
    * Return the parameters of the function-typed parameter.
    */
   FormalParameterList get parameters;
 
   /**
    * Set the parameters of the function-typed parameter to the given
    * [parameters].
    */
@@ skipping 101 matching lines @@
  *        'if' '(' [Expression] ')' [Statement] ('else' [Statement])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IfStatement extends Statement {
   /**
    * Initialize a newly created if statement. The [elseKeyword] and
    * [elseStatement] can be `null` if there is no else clause.
    */
   factory IfStatement(
-      Token ifKeyword,
-      Token leftParenthesis,
-      Expression condition,
-      Token rightParenthesis,
-      Statement thenStatement,
-      Token elseKeyword,
-      Statement elseStatement) = IfStatementImpl;
+          Token ifKeyword,
+          Token leftParenthesis,
+          Expression condition,
+          Token rightParenthesis,
+          Statement thenStatement,
+          Token elseKeyword,
+          Statement elseStatement) =>
+      new IfStatementImpl(ifKeyword, leftParenthesis, condition,
+          rightParenthesis, thenStatement, elseKeyword, elseStatement);
 
   /**
    * Return the condition used to determine which of the statements is executed
    * next.
    */
   Expression get condition;
 
   /**
    * Set the condition used to determine which of the statements is executed
    * next to the given [expression].
@@ skipping 202 matching lines @@
 
   /**
    * Initialize a newly created import directive. Either or both of the
    * [comment] and [metadata] can be `null` if the function does not have the
    * corresponding attribute. The [deferredKeyword] can be `null` if the import
    * is not deferred. The [asKeyword] and [prefix] can be `null` if the import
    * does not specify a prefix. The list of [combinators] can be `null` if there
    * are no combinators.
    */
   factory ImportDirective(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      StringLiteral libraryUri,
-      List<Configuration> configurations,
-      Token deferredKeyword,
-      Token asKeyword,
-      SimpleIdentifier prefix,
-      List<Combinator> combinators,
-      Token semicolon) = ImportDirectiveImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token keyword,
+          StringLiteral libraryUri,
+          List<Configuration> configurations,
+          Token deferredKeyword,
+          Token asKeyword,
+          SimpleIdentifier prefix,
+          List<Combinator> combinators,
+          Token semicolon) =>
+      new ImportDirectiveImpl(
+          comment,
+          metadata,
+          keyword,
+          libraryUri,
+          configurations,
+          deferredKeyword,
+          asKeyword,
+          prefix,
+          combinators,
+          semicolon);
 
   /**
    * Return the token representing the 'as' keyword, or `null` if the imported
    * names are not prefixed.
    */
   Token get asKeyword;
 
   /**
    * Set the token representing the 'as' keyword to the given [token].
    */
@@ skipping 28 matching lines @@
  *    indexExpression ::=
  *        [Expression] '[' [Expression] ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IndexExpression extends Expression {
   /**
    * Initialize a newly created index expression.
    */
   factory IndexExpression.forCascade(Token period, Token leftBracket,
-      Expression index, Token rightBracket) = IndexExpressionImpl.forCascade;
+          Expression index, Token rightBracket) =>
+      new IndexExpressionImpl.forCascade(
+          period, leftBracket, index, rightBracket);
 
   /**
    * Initialize a newly created index expression.
    */
   factory IndexExpression.forTarget(Expression target, Token leftBracket,
-      Expression index, Token rightBracket) = IndexExpressionImpl.forTarget;
+          Expression index, Token rightBracket) =>
+      new IndexExpressionImpl.forTarget(
+          target, leftBracket, index, rightBracket);
 
   /**
    * Return the auxiliary elements associated with this identifier, or `null` if
    * this identifier is not in both a getter and setter context. The auxiliary
    * elements hold the static and propagated elements associated with the getter
    * context.
    */
   // TODO(brianwilkerson) Replace this API.
   AuxiliaryElements get auxiliaryElements;
 
@@ skipping 136 matching lines @@
  *
  *    newExpression ::=
  *        ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InstanceCreationExpression extends Expression {
   /**
    * Initialize a newly created instance creation expression.
    */
-  factory InstanceCreationExpression(
-      Token keyword,
-      ConstructorName constructorName,
-      ArgumentList argumentList) = InstanceCreationExpressionImpl;
+  factory InstanceCreationExpression(Token keyword,
+          ConstructorName constructorName, ArgumentList argumentList) =>
+      new InstanceCreationExpressionImpl(
+          keyword, constructorName, argumentList);
 
   /**
    * Return the list of arguments to the constructor.
    */
   ArgumentList get argumentList;
 
   /**
    * Set the list of arguments to the constructor to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList);
@@ skipping 101 matching lines @@
  *        '$' [SimpleIdentifier]
  *      | '$' '{' [Expression] '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InterpolationExpression extends InterpolationElement {
   /**
    * Initialize a newly created interpolation expression.
    */
   factory InterpolationExpression(
-          Token leftBracket, Expression expression, Token rightBracket) =
-      InterpolationExpressionImpl;
+          Token leftBracket, Expression expression, Token rightBracket) =>
+      new InterpolationExpressionImpl(leftBracket, expression, rightBracket);
 
   /**
    * Return the expression to be evaluated for the value to be converted into a
    * string.
    */
   Expression get expression;
 
   /**
    * Set the expression to be evaluated for the value to be converted into a
    * string to the given [expression].
@@ skipping 147 matching lines @@
  *        [Expression] 'is' '!'? [TypeName]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IsExpression extends Expression {
   /**
    * Initialize a newly created is expression. The [notOperator] can be `null`
    * if the sense of the test is not negated.
    */
   factory IsExpression(Expression expression, Token isOperator,
-      Token notOperator, TypeName type) = IsExpressionImpl;
+          Token notOperator, TypeName type) =>
+      new IsExpressionImpl(expression, isOperator, notOperator, type);
 
   /**
    * Return the expression used to compute the value whose type is being tested.
    */
   Expression get expression;
 
   /**
    * Set the expression used to compute the value whose type is being tested to
    * the given [expression].
    */
@@ skipping 35 matching lines @@
  *
  *    label ::=
  *        [SimpleIdentifier] ':'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Label extends AstNode {
   /**
    * Initialize a newly created label.
    */
-  factory Label(SimpleIdentifier label, Token colon) = LabelImpl;
+  factory Label(SimpleIdentifier label, Token colon) =>
+      new LabelImpl(label, colon);
 
   /**
    * Return the colon that separates the label from the statement.
    */
   Token get colon;
 
   /**
    * Set the colon that separates the label from the statement to the given
    * [token].
    */
@@ skipping 15 matching lines @@
  *
  *    labeledStatement ::=
  *       [Label]+ [Statement]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class LabeledStatement extends Statement {
   /**
    * Initialize a newly created labeled statement.
    */
-  factory LabeledStatement(List<Label> labels, Statement statement) =
-      LabeledStatementImpl;
+  factory LabeledStatement(List<Label> labels, Statement statement) =>
+      new LabeledStatementImpl(labels, statement);
 
   /**
    * Return the labels being associated with the statement.
    */
   NodeList<Label> get labels;
 
   /**
    * Return the statement with which the labels are being associated.
    */
   Statement get statement;
@@ skipping 12 matching lines @@
  *        [Annotation] 'library' [Identifier] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class LibraryDirective extends Directive {
   /**
    * Initialize a newly created library directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
-  factory LibraryDirective(
-      Comment comment,
-      List<Annotation> metadata,
-      Token libraryKeyword,
-      LibraryIdentifier name,
-      Token semicolon) = LibraryDirectiveImpl;
+  factory LibraryDirective(Comment comment, List<Annotation> metadata,
+          Token libraryKeyword, LibraryIdentifier name, Token semicolon) =>
+      new LibraryDirectiveImpl(
+          comment, metadata, libraryKeyword, name, semicolon);
 
   /**
    * Return the token representing the 'library' keyword.
    */
   Token get libraryKeyword;
 
   /**
    * Set the token representing the 'library' keyword to the given [token].
    */
   void set libraryKeyword(Token token);
@@ skipping 157 matching lines @@
  *
  *    mapLiteralEntry ::=
  *        [Expression] ':' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapLiteralEntry extends AstNode {
   /**
    * Initialize a newly created map literal entry.
    */
-  factory MapLiteralEntry(Expression key, Token separator, Expression value) =
-      MapLiteralEntryImpl;
+  factory MapLiteralEntry(Expression key, Token separator, Expression value) =>
+      new MapLiteralEntryImpl(key, separator, value);
 
   /**
    * Return the expression computing the key with which the value will be
    * associated.
    */
   Expression get key;
 
   /**
    * Set the expression computing the key with which the value will be
    * associated to the given [string].
@@ skipping 45 matching lines @@
    * [comment] and [metadata] can be `null` if the declaration does not have the
    * corresponding attribute. The [externalKeyword] can be `null` if the method
    * is not external. The [modifierKeyword] can be `null` if the method is
    * neither abstract nor static. The [returnType] can be `null` if no return
    * type was specified. The [propertyKeyword] can be `null` if the method is
    * neither a getter or a setter. The [operatorKeyword] can be `null` if the
    * method does not implement an operator. The [parameters] must be `null` if
    * this method declares a getter.
    */
   factory MethodDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      Token externalKeyword,
-      Token modifierKeyword,
-      TypeName returnType,
-      Token propertyKeyword,
-      Token operatorKeyword,
-      SimpleIdentifier name,
-      TypeParameterList typeParameters,
-      FormalParameterList parameters,
-      FunctionBody body) = MethodDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token externalKeyword,
+          Token modifierKeyword,
+          TypeName returnType,
+          Token propertyKeyword,
+          Token operatorKeyword,
+          SimpleIdentifier name,
+          TypeParameterList typeParameters,
+          FormalParameterList parameters,
+          FunctionBody body) =>
+      new MethodDeclarationImpl(
+          comment,
+          metadata,
+          externalKeyword,
+          modifierKeyword,
+          returnType,
+          propertyKeyword,
+          operatorKeyword,
+          name,
+          typeParameters,
+          parameters,
+          body);
 
   /**
    * Return the body of the method.
    */
   FunctionBody get body;
 
   /**
    * Set the body of the method to the given [functionBody].
    */
   void set body(FunctionBody functionBody);
@@ skipping 127 matching lines @@
  *        ([Expression] '.')? [SimpleIdentifier] [TypeArgumentList]? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MethodInvocation extends InvocationExpression {
   /**
    * Initialize a newly created method invocation. The [target] and [operator]
    * can be `null` if there is no target.
    */
   factory MethodInvocation(
-      Expression target,
-      Token operator,
-      SimpleIdentifier methodName,
-      TypeArgumentList typeArguments,
-      ArgumentList argumentList) = MethodInvocationImpl;
+          Expression target,
+          Token operator,
+          SimpleIdentifier methodName,
+          TypeArgumentList typeArguments,
+          ArgumentList argumentList) =>
+      new MethodInvocationImpl(
+          target, operator, methodName, typeArguments, argumentList);
 
   /**
    * Set the list of arguments to the method to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList);
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of
    * this expression is not stored locally but is stored in the nearest ancestor
    * that is a [CascadeExpression].
@@ skipping 116 matching lines @@
  *
  *    namedExpression ::=
  *        [Label] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NamedExpression extends Expression {
   /**
    * Initialize a newly created named expression..
    */
-  factory NamedExpression(Label name, Expression expression) =
-      NamedExpressionImpl;
+  factory NamedExpression(Label name, Expression expression) =>
+      new NamedExpressionImpl(name, expression);
 
   /**
    * Return the element representing the parameter being named by this
    * expression, or `null` if the AST structure has not been resolved or if
    * there is no parameter with the same name as this expression.
    */
   ParameterElement get element;
 
   /**
    * Return the expression with which the name is associated.
@@ skipping 60 matching lines @@
  *
  *    nativeClause ::=
  *        'native' [StringLiteral]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NativeClause extends AstNode {
   /**
    * Initialize a newly created native clause.
    */
-  factory NativeClause(Token nativeKeyword, StringLiteral name) =
-      NativeClauseImpl;
+  factory NativeClause(Token nativeKeyword, StringLiteral name) =>
+      new NativeClauseImpl(nativeKeyword, name);
 
   /**
    * Return the name of the native object that implements the class.
    */
   StringLiteral get name;
 
   /**
    * Set the name of the native object that implements the class to the given
    * [name].
    */
@@ skipping 18 matching lines @@
  *        'native' [SimpleStringLiteral] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NativeFunctionBody extends FunctionBody {
   /**
    * Initialize a newly created function body consisting of the 'native' token,
    * a string literal, and a semicolon.
    */
   factory NativeFunctionBody(
-          Token nativeKeyword, StringLiteral stringLiteral, Token semicolon) =
-      NativeFunctionBodyImpl;
+          Token nativeKeyword, StringLiteral stringLiteral, Token semicolon) =>
+      new NativeFunctionBodyImpl(nativeKeyword, stringLiteral, semicolon);
 
   /**
    * Return the token representing 'native' that marks the start of the function
    * body.
    */
   Token get nativeKeyword;
 
   /**
    * Set the token representing 'native' that marks the start of the function
    * body to the given [token].
@@ skipping 153 matching lines @@
  *    parenthesizedExpression ::=
  *        '(' [Expression] ')'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ParenthesizedExpression extends Expression {
   /**
    * Initialize a newly created parenthesized expression.
    */
   factory ParenthesizedExpression(Token leftParenthesis, Expression expression,
-      Token rightParenthesis) = ParenthesizedExpressionImpl;
+          Token rightParenthesis) =>
+      new ParenthesizedExpressionImpl(
+          leftParenthesis, expression, rightParenthesis);
 
   /**
    * Return the expression within the parentheses.
    */
   Expression get expression;
 
   /**
    * Set the expression within the parentheses to the given [expression].
    */
   void set expression(Expression expression);
@@ skipping 69 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PartOfDirective extends Directive {
   /**
    * Initialize a newly created part-of directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute.
    */
   factory PartOfDirective(
-      Comment comment,
-      List<Annotation> metadata,
-      Token partKeyword,
-      Token ofKeyword,
-      LibraryIdentifier libraryName,
-      Token semicolon) = PartOfDirectiveImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          Token partKeyword,
+          Token ofKeyword,
+          LibraryIdentifier libraryName,
+          Token semicolon) =>
+      new PartOfDirectiveImpl(
+          comment, metadata, partKeyword, ofKeyword, libraryName, semicolon);
 
   /**
    * Return the name of the library that the containing compilation unit is part
    * of.
    */
   LibraryIdentifier get libraryName;
 
   /**
    * Set the name of the library that the containing compilation unit is part of
    * to the given [libraryName].
@@ skipping 36 matching lines @@
  *
  *    postfixExpression ::=
  *        [Expression] [Token]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PostfixExpression extends Expression {
   /**
    * Initialize a newly created postfix expression.
    */
-  factory PostfixExpression(Expression operand, Token operator) =
-      PostfixExpressionImpl;
+  factory PostfixExpression(Expression operand, Token operator) =>
+      new PostfixExpressionImpl(operand, operator);
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement;
 
@@ skipping 53 matching lines @@
  *    prefixedIdentifier ::=
  *        [SimpleIdentifier] '.' [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PrefixedIdentifier extends Identifier {
   /**
    * Initialize a newly created prefixed identifier.
    */
   factory PrefixedIdentifier(
-          SimpleIdentifier prefix, Token period, SimpleIdentifier identifier) =
-      PrefixedIdentifierImpl;
+          SimpleIdentifier prefix, Token period, SimpleIdentifier identifier) =>
+      new PrefixedIdentifierImpl(prefix, period, identifier);
 
   /**
    * Return the identifier being prefixed.
    */
   SimpleIdentifier get identifier;
 
   /**
    * Set the identifier being prefixed to the given [identifier].
    */
   void set identifier(SimpleIdentifier identifier);
@@ skipping 36 matching lines @@
  *
  *    prefixExpression ::=
  *        [Token] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PrefixExpression extends Expression {
   /**
    * Initialize a newly created prefix expression.
    */
-  factory PrefixExpression(Token operator, Expression operand) =
-      PrefixExpressionImpl;
+  factory PrefixExpression(Token operator, Expression operand) =>
+      new PrefixExpressionImpl(operator, operand);
 
   /**
    * Return the best element available for this operator. If resolution was able
    * to find a better element based on type propagation, that element will be
    * returned. Otherwise, the element found using the result of static analysis
    * will be returned. If resolution has not been performed, then `null` will be
    * returned.
    */
   MethodElement get bestElement;
 
@@ skipping 56 matching lines @@
  *    propertyAccess ::=
  *        [Expression] '.' [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PropertyAccess extends Expression {
   /**
    * Initialize a newly created property access expression.
    */
   factory PropertyAccess(
-          Expression target, Token operator, SimpleIdentifier propertyName) =
-      PropertyAccessImpl;
+          Expression target, Token operator, SimpleIdentifier propertyName) =>
+      new PropertyAccessImpl(target, operator, propertyName);
 
   /**
    * Return `true` if this expression is cascaded. If it is, then the target of
    * this expression is not stored locally but is stored in the nearest ancestor
    * that is a [CascadeExpression].
    */
   bool get isCascaded;
 
   /**
    * Return the property access operator.
@@ skipping 47 matching lines @@
  *        'this' ('.' identifier)? arguments
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class RedirectingConstructorInvocation extends ConstructorInitializer {
   /**
    * Initialize a newly created redirecting invocation to invoke the constructor
    * with the given name with the given arguments. The [constructorName] can be
    * `null` if the constructor being invoked is the unnamed constructor.
    */
-  factory RedirectingConstructorInvocation(
-      Token thisKeyword,
-      Token period,
-      SimpleIdentifier constructorName,
-      ArgumentList argumentList) = RedirectingConstructorInvocationImpl;
+  factory RedirectingConstructorInvocation(Token thisKeyword, Token period,
+          SimpleIdentifier constructorName, ArgumentList argumentList) =>
+      new RedirectingConstructorInvocationImpl(
+          thisKeyword, period, constructorName, argumentList);
 
   /**
    * Return the list of arguments to the constructor.
    */
   ArgumentList get argumentList;
 
   /**
    * Set the list of arguments to the constructor to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList);
@@ skipping 78 matching lines @@
  *        'return' [Expression]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ReturnStatement extends Statement {
   /**
    * Initialize a newly created return statement. The [expression] can be `null`
    * if no explicit value was provided.
    */
   factory ReturnStatement(
-          Token returnKeyword, Expression expression, Token semicolon) =
-      ReturnStatementImpl;
+          Token returnKeyword, Expression expression, Token semicolon) =>
+      new ReturnStatementImpl(returnKeyword, expression, semicolon);
 
   /**
    * Return the expression computing the value to be returned, or `null` if no
    * explicit value was provided.
    */
   Expression get expression;
 
   /**
    * Set the expression computing the value to be returned to the given
    * [expression].
@@ skipping 76 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleFormalParameter extends NormalFormalParameter {
   /**
    * Initialize a newly created formal parameter. Either or both of the
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
-  factory SimpleFormalParameter(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      TypeName type,
-      SimpleIdentifier identifier) = SimpleFormalParameterImpl;
+  factory SimpleFormalParameter(Comment comment, List<Annotation> metadata,
+          Token keyword, TypeName type, SimpleIdentifier identifier) =>
+      new SimpleFormalParameterImpl(
+          comment, metadata, keyword, type, identifier);
 
   /**
    * Return the token representing either the 'final', 'const' or 'var' keyword,
    * or `null` if no keyword was used.
    */
   Token get keyword;
 
   /**
    * Set the token representing either the 'final', 'const' or 'var' keyword to
    * the given [token].
@@ skipping 275 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SuperConstructorInvocation extends ConstructorInitializer {
   /**
    * Initialize a newly created super invocation to invoke the inherited
    * constructor with the given name with the given arguments. The [period] and
    * [constructorName] can be `null` if the constructor being invoked is the
    * unnamed constructor.
    */
-  factory SuperConstructorInvocation(
-      Token superKeyword,
-      Token period,
-      SimpleIdentifier constructorName,
-      ArgumentList argumentList) = SuperConstructorInvocationImpl;
+  factory SuperConstructorInvocation(Token superKeyword, Token period,
+          SimpleIdentifier constructorName, ArgumentList argumentList) =>
+      new SuperConstructorInvocationImpl(
+          superKeyword, period, constructorName, argumentList);
 
   /**
    * Return the list of arguments to the constructor.
    */
   ArgumentList get argumentList;
 
   /**
    * Set the list of arguments to the constructor to the given [argumentList].
    */
   void set argumentList(ArgumentList argumentList);
@@ skipping 78 matching lines @@
  *        [SimpleIdentifier]* 'case' [Expression] ':' [Statement]*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SwitchCase extends SwitchMember {
   /**
    * Initialize a newly created switch case. The list of [labels] can be `null`
    * if there are no labels.
    */
   factory SwitchCase(List<Label> labels, Token keyword, Expression expression,
-      Token colon, List<Statement> statements) = SwitchCaseImpl;
+          Token colon, List<Statement> statements) =>
+      new SwitchCaseImpl(labels, keyword, expression, colon, statements);
 
   /**
    * Return the expression controlling whether the statements will be executed.
    */
   Expression get expression;
 
   /**
    * Set the expression controlling whether the statements will be executed to
    * the given [expression].
    */
@@ skipping 69 matching lines @@
  *        'switch' '(' [Expression] ')' '{' [SwitchCase]* [SwitchDefault]? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SwitchStatement extends Statement {
   /**
    * Initialize a newly created switch statement. The list of [members] can be
    * `null` if there are no switch members.
    */
   factory SwitchStatement(
-      Token switchKeyword,
-      Token leftParenthesis,
-      Expression expression,
-      Token rightParenthesis,
-      Token leftBracket,
-      List<SwitchMember> members,
-      Token rightBracket) = SwitchStatementImpl;
+          Token switchKeyword,
+          Token leftParenthesis,
+          Expression expression,
+          Token rightParenthesis,
+          Token leftBracket,
+          List<SwitchMember> members,
+          Token rightBracket) =>
+      new SwitchStatementImpl(switchKeyword, leftParenthesis, expression,
+          rightParenthesis, leftBracket, members, rightBracket);
 
   /**
    * Return the expression used to determine which of the switch members will be
    * selected.
    */
   Expression get expression;
 
   /**
    * Set the expression used to determine which of the switch members will be
    * selected to the given [expression].
@@ skipping 117 matching lines @@
  *
  *    throwExpression ::=
  *        'throw' [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ThrowExpression extends Expression {
   /**
    * Initialize a newly created throw expression.
    */
-  factory ThrowExpression(Token throwKeyword, Expression expression) =
-      ThrowExpressionImpl;
+  factory ThrowExpression(Token throwKeyword, Expression expression) =>
+      new ThrowExpressionImpl(throwKeyword, expression);
 
   /**
    * Return the expression computing the exception to be thrown.
    */
   Expression get expression;
 
   /**
    * Set the expression computing the exception to be thrown to the given
    * [expression].
    */
@@ skipping 19 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TopLevelVariableDeclaration extends CompilationUnitMember {
   /**
    * Initialize a newly created top-level variable declaration. Either or both
    * of the [comment] and [metadata] can be `null` if the variable does not have
    * the corresponding attribute.
    */
   factory TopLevelVariableDeclaration(
-      Comment comment,
-      List<Annotation> metadata,
-      VariableDeclarationList variableList,
-      Token semicolon) = TopLevelVariableDeclarationImpl;
+          Comment comment,
+          List<Annotation> metadata,
+          VariableDeclarationList variableList,
+          Token semicolon) =>
+      new TopLevelVariableDeclarationImpl(
+          comment, metadata, variableList, semicolon);
 
   /**
    * Return the semicolon terminating the declaration.
    */
   Token get semicolon;
 
   /**
    * Set the semicolon terminating the declaration to the given [token].
    */
   void set semicolon(Token token);
@@ skipping 21 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TryStatement extends Statement {
   /**
    * Initialize a newly created try statement. The list of [catchClauses] can be
    * `null` if there are no catch clauses. The [finallyKeyword] and
    * [finallyBlock] can be `null` if there is no finally clause.
    */
   factory TryStatement(
-      Token tryKeyword,
-      Block body,
-      List<CatchClause> catchClauses,
-      Token finallyKeyword,
-      Block finallyBlock) = TryStatementImpl;
+          Token tryKeyword,
+          Block body,
+          List<CatchClause> catchClauses,
+          Token finallyKeyword,
+          Block finallyBlock) =>
+      new TryStatementImpl(
+          tryKeyword, body, catchClauses, finallyKeyword, finallyBlock);
 
   /**
    * Return the body of the statement.
    */
   Block get body;
 
   /**
    * Set the body of the statement to the given [block].
    */
   void set body(Block block);
@@ skipping 152 matching lines @@
  *    typeName ::=
  *        [Identifier] typeArguments?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeName extends AstNode {
   /**
    * Initialize a newly created type name. The [typeArguments] can be `null` if
    * there are no type arguments.
    */
-  factory TypeName(Identifier name, TypeArgumentList typeArguments) =
-      TypeNameImpl;
+  factory TypeName(Identifier name, TypeArgumentList typeArguments) =>
+      new TypeNameImpl(name, typeArguments);
 
   /**
    * Return `true` if this type is a deferred type.
    *
    * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
    * </i>p.T</i> where <i>p</i> is a deferred prefix.
    */
   bool get isDeferred;
 
   /**
@@ skipping 38 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeParameter extends Declaration {
   /**
    * Initialize a newly created type parameter. Either or both of the [comment]
    * and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [extendsKeyword] and [bound] can be `null` if
    * the parameter does not have an upper bound.
    */
-  factory TypeParameter(
-      Comment comment,
-      List<Annotation> metadata,
-      SimpleIdentifier name,
-      Token extendsKeyword,
-      TypeName bound) = TypeParameterImpl;
+  factory TypeParameter(Comment comment, List<Annotation> metadata,
+          SimpleIdentifier name, Token extendsKeyword, TypeName bound) =>
+      new TypeParameterImpl(comment, metadata, name, extendsKeyword, bound);
 
   /**
    * Return the name of the upper bound for legal arguments, or `null` if there
    * is no explicit upper bound.
    */
   TypeName get bound;
 
   /**
    * Set the name of the upper bound for legal arguments to the given
    * [typeName].
@@ skipping 140 matching lines @@
  * extend [Declaration].
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclaration extends Declaration {
   /**
    * Initialize a newly created variable declaration. The [equals] and
    * [initializer] can be `null` if there is no initializer.
    */
   factory VariableDeclaration(
-          SimpleIdentifier name, Token equals, Expression initializer) =
-      VariableDeclarationImpl;
+          SimpleIdentifier name, Token equals, Expression initializer) =>
+      new VariableDeclarationImpl(name, equals, initializer);
 
   @override
   VariableElement get element;
 
   /**
    * Return the equal sign separating the variable name from the initial value,
    * or `null` if the initial value was not specified.
    */
   Token get equals;
 
@@ skipping 52 matching lines @@
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclarationList extends AnnotatedNode {
   /**
    * Initialize a newly created variable declaration list. Either or both of the
    * [comment] and [metadata] can be `null` if the variable list does not have
    * the corresponding attribute. The [keyword] can be `null` if a type was
    * specified. The [type] must be `null` if the keyword is 'var'.
    */
-  factory VariableDeclarationList(
-      Comment comment,
-      List<Annotation> metadata,
-      Token keyword,
-      TypeName type,
-      List<VariableDeclaration> variables) = VariableDeclarationListImpl;
+  factory VariableDeclarationList(Comment comment, List<Annotation> metadata,
+          Token keyword, TypeName type, List<VariableDeclaration> variables) =>
+      new VariableDeclarationListImpl(
+          comment, metadata, keyword, type, variables);
 
   /**
    * Return `true` if the variables in this list were declared with the 'const'
    * modifier.
    */
   bool get isConst;
 
   /**
    * Return `true` if the variables in this list were declared with the 'final'
    * modifier. Variables that are declared with the 'const' modifier will return
@@ skipping 38 matching lines @@
  *    variableDeclarationStatement ::=
  *        [VariableDeclarationList] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class VariableDeclarationStatement extends Statement {
   /**
    * Initialize a newly created variable declaration statement.
    */
   factory VariableDeclarationStatement(
-          VariableDeclarationList variableList, Token semicolon) =
-      VariableDeclarationStatementImpl;
+          VariableDeclarationList variableList, Token semicolon) =>
+      new VariableDeclarationStatementImpl(variableList, semicolon);
 
   /**
    * Return the semicolon terminating the statement.
    */
   Token get semicolon;
 
   /**
    * Set the semicolon terminating the statement to the given [token].
    */
   void set semicolon(Token token);
@@ skipping 14 matching lines @@
  *
  *    whileStatement ::=
  *        'while' '(' [Expression] ')' [Statement]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class WhileStatement extends Statement {
   /**
    * Initialize a newly created while statement.
    */
-  factory WhileStatement(
-      Token whileKeyword,
-      Token leftParenthesis,
-      Expression condition,
-      Token rightParenthesis,
-      Statement body) = WhileStatementImpl;
+  factory WhileStatement(Token whileKeyword, Token leftParenthesis,
+          Expression condition, Token rightParenthesis, Statement body) =>
+      new WhileStatementImpl(
+          whileKeyword, leftParenthesis, condition, rightParenthesis, body);
 
   /**
    * Return the body of the loop.
    */
   Statement get body;
 
   /**
    * Set the body of the loop to the given [statement].
    */
   void set body(Statement statement);
@@ skipping 79 matching lines @@
  *        'yield' '*'? [Expression] ‘;’
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class YieldStatement extends Statement {
   /**
    * Initialize a newly created yield expression. The [star] can be `null` if no
    * star was provided.
    */
   factory YieldStatement(Token yieldKeyword, Token star, Expression expression,
-      Token semicolon) = YieldStatementImpl;
+          Token semicolon) =>
+      new YieldStatementImpl(yieldKeyword, star, expression, semicolon);
 
   /**
    * Return the expression whose value will be yielded.
    */
   Expression get expression;
 
   /**
    * Set the expression whose value will be yielded to the given [expression].
    */
   void set expression(Expression expression);
@@ skipping 21 matching lines @@
   /**
    * Return the 'yield' keyword.
    */
   Token get yieldKeyword;
 
   /**
    * Return the 'yield' keyword to the given [token].
    */
   void set yieldKeyword(Token token);
 }