Revert "Transition analyzer and analysis_server to new astFactory; remove old AST factory methods."

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 22 matching lines @@
  * When an AST is resolved, the identifiers in the AST will be associated with
  * the elements that they refer to and every expression in the AST will have a
  * type associated with it.
  */
 library analyzer.dart.ast.ast;
 
 import 'package:analyzer/dart/ast/syntactic_entity.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart' show AuxiliaryElements;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart' show LineInfo, Source;
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
 /**
  * Two or more string literals that are implicitly concatenated because of being
  * adjacent (separated only by whitespace).
  *
  * While the grammar only allows adjacent strings when all of the strings are of
  * the same kind (single line or multi-line), this class doesn't enforce that
  * restriction.
  *
  *    adjacentStrings ::=
  *        [StringLiteral] [StringLiteral]+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AdjacentStrings extends StringLiteral {
   /**
+   * Initialize a newly created list of adjacent strings. To be syntactically
+   * valid, the list of [strings] must contain at least two elements.
+   */
+  factory AdjacentStrings(List<StringLiteral> strings) = AdjacentStringsImpl;
+
+  /**
    * Return the strings that are implicitly concatenated.
    */
   NodeList<StringLiteral> get strings;
 }
 
 /**
  * An AST node that can be annotated with both a documentation comment and a
  * list of annotations.
  *
  * Clients may not extend, implement or mix-in this class.
@@ skipping 34 matching lines @@
  *    metadata ::=
  *        annotation*
  *
  *    annotation ::=
  *        '@' [Identifier] ('.' [SimpleIdentifier])? [ArgumentList]?
  *
  * 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) =>
+      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].
    */
   void set arguments(ArgumentList arguments);
 
@@ skipping 73 matching lines @@
  *        '(' arguments? ')'
  *
  *    arguments ::=
  *        [NamedExpression] (',' [NamedExpression])*
  *      | [Expression] (',' [Expression])* (',' [NamedExpression])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ArgumentList extends AstNode {
   /**
+   * Initialize a newly created list of arguments. The list of [arguments] can
+   * be `null` if there are no arguments.
+   */
+  factory ArgumentList(Token leftParenthesis, List<Expression> arguments,
+      Token rightParenthesis) = ArgumentListImpl;
+
+  /**
    * Return the expressions producing the values of the arguments. Although the
    * language requires that positional arguments appear before named arguments,
    * this class allows them to be intermixed.
    */
   NodeList<Expression> get arguments;
 
   /**
    * Set the parameter elements corresponding to each of the arguments in this
    * list to the given list of [parameters]. The list of parameters must be the
    * same length as the number of arguments, but can contain `null` entries if a
@@ skipping 33 matching lines @@
 /**
  * An as expression.
  *
  *    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) =>
+      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 19 matching lines @@
 }
 
 /**
  * An assert in the initializer list of a constructor.
  *
  *    assertInitializer ::=
  *        'assert' '(' [Expression] (',' [Expression])? ')'
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class AssertInitializer implements Assertion, ConstructorInitializer {}
+abstract class AssertInitializer implements Assertion, ConstructorInitializer {
+  /**
+   * Initialize a newly created assert initializer. The [comma] and [message]
+   * can be `null` if there is no message.
+   */
+  factory AssertInitializer(
+          Token assertKeyword,
+          Token leftParenthesis,
+          Expression condition,
+          Token comma,
+          Expression message,
+          Token rightParenthesis) =>
+      new AssertInitializerImpl(assertKeyword, leftParenthesis, condition,
+          comma, message, rightParenthesis);
+}
 
 /**
  * An assertion, either in a block or in the initializer list of a constructor.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Assertion implements AstNode {
   /**
    * Return the token representing the 'assert' keyword.
    */
@@ skipping 63 matching lines @@
 /**
  * An assert statement.
  *
  *    assertStatement ::=
  *        'assert' '(' [Expression] (',' [Expression])? ')' ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AssertStatement implements Assertion, 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) =>
+      new AssertStatementImpl(assertKeyword, leftParenthesis, condition, comma,
+          message, rightParenthesis, 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);
 }
 
 /**
  * An assignment expression.
  *
  *    assignmentExpression ::=
  *        [Expression] operator [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class AssignmentExpression extends Expression
     implements MethodReferenceExpression {
   /**
+   * Initialize a newly created assignment expression.
+   */
+  factory AssignmentExpression(
+          Expression leftHandSide, Token operator, Expression rightHandSide) =>
+      new AssignmentExpressionImpl(leftHandSide, operator, rightHandSide);
+
+  /**
    * Return the expression used to compute the left hand side.
    */
   Expression get leftHandSide;
 
   /**
    * Return the expression used to compute the left hand side.
    */
   void set leftHandSide(Expression expression);
 
   /**
@@ skipping 365 matching lines @@
 /**
  * An await expression.
  *
  *    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) =>
+      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 11 matching lines @@
  * A binary (infix) expression.
  *
  *    binaryExpression ::=
  *        [Expression] [Token] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BinaryExpression extends Expression
     implements MethodReferenceExpression {
   /**
+   * Initialize a newly created binary expression.
+   */
+  factory BinaryExpression(
+          Expression leftOperand, Token operator, Expression rightOperand) =>
+      new BinaryExpressionImpl(leftOperand, operator, rightOperand);
+
+  /**
    * Return the expression used to compute the left operand.
    */
   Expression get leftOperand;
 
   /**
    * Set the expression used to compute the left operand to the given
    * [expression].
    */
   void set leftOperand(Expression expression);
 
@@ skipping 22 matching lines @@
 /**
  * A sequence of statements.
  *
  *    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) =>
+      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 15 matching lines @@
 /**
  * A function body that consists of a block of statements.
  *
  *    blockFunctionBody ::=
  *        ('async' | 'async' '*' | 'sync' '*')? [Block]
  *
  * 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) =>
+      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 10 matching lines @@
 /**
  * A boolean literal expression.
  *
  *    booleanLiteral ::=
  *        'false' | 'true'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class BooleanLiteral extends Literal {
   /**
+   * Initialize a newly created boolean literal.
+   */
+  factory BooleanLiteral(Token literal, bool value) = BooleanLiteralImpl;
+
+  /**
    * Return the token representing the literal.
    */
   Token get literal;
 
   /**
    * Set the token representing the literal to the given [token].
    */
   void set literal(Token token);
 
   /**
    * Return the value of the literal.
    */
   bool get value;
 }
 
 /**
  * A break statement.
  *
  *    breakStatement ::=
  *        '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) =>
+      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 48 matching lines @@
  *        (assignmentOperator expressionWithoutCascade)?
  *
  *    cascadeSelector ::=
  *        '[ ' expression '] '
  *      | 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) =>
+      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;
 
   /**
    * Set the target of the cascade sections to the given [target].
    */
   void set target(Expression target);
 }
 
 /**
  * A catch clause within a try statement.
  *
  *    onPart ::=
  *        catchPart [Block]
  *      | 'on' type catchPart? [Block]
  *
  *    catchPart ::=
  *        'catch' '(' [SimpleIdentifier] (',' [SimpleIdentifier])? ')'
  *
  * 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) =>
+      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 93 matching lines @@
  *    classDeclaration ::=
  *        'abstract'? 'class' [SimpleIdentifier] [TypeParameterList]?
  *        ([ExtendsClause] [WithClause]?)?
  *        [ImplementsClause]?
  *        '{' [ClassMember]* '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ClassDeclaration extends NamedCompilationUnitMember {
   /**
+   * 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) =>
+      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 127 matching lines @@
  *    classTypeAlias ::=
  *        [SimpleIdentifier] [TypeParameterList]? '=' 'abstract'? mixinApplication
  *
  *    mixinApplication ::=
  *        [TypeName] [WithClause] [ImplementsClause]? ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 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) =>
+      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].
    */
   void set abstractKeyword(Token token);
 
@@ skipping 95 matching lines @@
  *        '/ *' CHARACTER* '&#42;/'
  *
  *    documentationComment ::=
  *        '/ **' (CHARACTER | [CommentReference])* '&#42;/'
  *      | ('///' (CHARACTER - EOL)* EOL)+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class Comment extends AstNode {
   /**
+   * Initialize a newly created comment. The list of [tokens] must contain at
+   * least one token. The [type] is the type of the comment. The list of
+   * [references] can be empty if the comment does not contain any embedded
+   * references.
+   */
+  factory Comment(List<Token> tokens, CommentType type,
+      List<CommentReference> references) = CommentImpl;
+
+  /**
    * Return `true` if this is a block comment.
    */
   bool get isBlock;
 
   /**
    * Return `true` if this is a documentation comment.
    */
   bool get isDocumentation;
 
   /**
    * Return `true` if this is an end-of-line comment.
    */
   bool get isEndOfLine;
 
   /**
    * Return the references embedded within the documentation comment.
    */
   NodeList<CommentReference> get references;
 
   /**
    * Return the tokens representing the comment.
    */
   List<Token> get tokens;
+
+  /**
+   * Create a block comment consisting of the given [tokens].
+   */
+  static Comment createBlockComment(List<Token> tokens) =>
+      CommentImpl.createBlockComment(tokens);
+
+  /**
+   * Create a documentation comment consisting of the given [tokens].
+   */
+  static Comment createDocumentationComment(List<Token> tokens) =>
+      CommentImpl.createDocumentationComment(tokens);
+
+  /**
+   * Create a documentation comment consisting of the given [tokens] and having
+   * the given [references] embedded within it.
+   */
+  static Comment createDocumentationCommentWithReferences(
+          List<Token> tokens, List<CommentReference> references) =>
+      CommentImpl.createDocumentationCommentWithReferences(tokens, references);
+
+  /**
+   * Create an end-of-line comment consisting of the given [tokens].
+   */
+  static Comment createEndOfLineComment(List<Token> tokens) =>
+      CommentImpl.createEndOfLineComment(tokens);
 }
 
 /**
  * A reference to a Dart element that is found within a documentation comment.
  *
  *    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) =>
+      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 28 matching lines @@
  *        [ImportDirective]
  *      | [ExportDirective]
  *
  *    declarations ::=
  *        [CompilationUnitMember]*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 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) =>
+      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.
    */
   NodeList<CompilationUnitMember> get declarations;
 
@@ skipping 68 matching lines @@
 /**
  * A conditional expression.
  *
  *    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) =>
+      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].
    */
   void set colon(Token token);
@@ skipping 55 matching lines @@
  *    test ::=
  *        dottedName ('==' stringLiteral)?
  *
  *    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) =>
+      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].
    */
   void set equalToken(Token token);
 
@@ skipping 106 matching lines @@
  *    factoryName ::=
  *        [Identifier] ('.' [SimpleIdentifier])?
  *
  *    initializerList ::=
  *        ':' [ConstructorInitializer] (',' [ConstructorInitializer])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorDeclaration extends ClassMember {
   /**
+   * Initialize a newly created constructor declaration. The [externalKeyword]
+   * can be `null` if the constructor is not external. Either or both of the
+   * [comment] and [metadata] can be `null` if the constructor does not have the
+   * corresponding attribute. The [constKeyword] can be `null` if the
+   * constructor cannot be used to create a constant. The [factoryKeyword] can
+   * 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) =>
+      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].
    */
   void set body(FunctionBody functionBody);
 
@@ skipping 117 matching lines @@
 /**
  * The initialization of a field within a constructor's initialization list.
  *
  *    fieldInitializer ::=
  *        ('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) =>
+      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].
    */
   void set equals(Token token);
@@ skipping 59 matching lines @@
  * The name of a constructor.
  *
  *    constructorName ::=
  *        type ('.' identifier)?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ConstructorName extends AstNode
     implements ConstructorReferenceNode {
   /**
+   * 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) =>
+      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].
    */
   void set name(SimpleIdentifier name);
 
@@ skipping 43 matching lines @@
 /**
  * A continue statement.
  *
  *    continueStatement ::=
  *        '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) =>
+      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 51 matching lines @@
 
 /**
  * The declaration of a single identifier.
  *
  *    declaredIdentifier ::=
  *        [Annotation] finalConstVarOrType [SimpleIdentifier]
  *
  * 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) =>
+      new DeclaredIdentifierImpl(comment, metadata, keyword, type, identifier);
+
   @override
   LocalVariableElement get element;
 
   /**
    * Return the name of the variable being declared.
    */
   SimpleIdentifier get identifier;
 
   /**
    * Set the name of the variable being declared to the given [identifier].
@@ skipping 44 matching lines @@
  *    defaultFormalParameter ::=
  *        [NormalFormalParameter] ('=' [Expression])?
  *
  *    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) =>
+      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].
    */
   void set defaultValue(Expression expression);
@@ skipping 61 matching lines @@
 /**
  * A do statement.
  *
  *    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) =>
+      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 61 matching lines @@
 /**
  * A dotted name, used in a configuration within an import or export directive.
  *
  *    dottedName ::=
  *        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DottedName extends AstNode {
   /**
+   * Initialize a newly created dotted name.
+   */
+  factory DottedName(List<SimpleIdentifier> components) = DottedNameImpl;
+
+  /**
    * Return the components of the identifier.
    */
   NodeList<SimpleIdentifier> get components;
 }
 
 /**
  * A floating point literal expression.
  *
  *    doubleLiteral ::=
  *        decimalDigit+ ('.' decimalDigit*)? exponent?
  *      | '.' decimalDigit+ exponent?
  *
  *    exponent ::=
  *        ('e' | 'E') ('+' | '-')? decimalDigit+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class DoubleLiteral extends Literal {
   /**
+   * Initialize a newly created floating point literal.
+   */
+  factory DoubleLiteral(Token literal, double value) = DoubleLiteralImpl;
+
+  /**
    * Return the token representing the literal.
    */
   Token get literal;
 
   /**
    * Set the token representing the literal to the given [token].
    */
   void set literal(Token token);
 
   /**
@@ skipping 11 matching lines @@
  * An empty function body, which can only appear in constructors or abstract
  * methods.
  *
  *    emptyFunctionBody ::=
  *        ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EmptyFunctionBody extends FunctionBody {
   /**
+   * Initialize a newly created function body.
+   */
+  factory EmptyFunctionBody(Token semicolon) = EmptyFunctionBodyImpl;
+
+  /**
    * Return the token representing the semicolon that marks the end of the
    * function body.
    */
   Token get semicolon;
 
   /**
    * Set the token representing the semicolon that marks the end of the
    * function body to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * An empty statement.
  *
  *    emptyStatement ::=
  *        ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class EmptyStatement extends Statement {
   /**
+   * Initialize a newly created empty statement.
+   */
+  factory EmptyStatement(Token semicolon) = EmptyStatementImpl;
+
+  /**
    * Return the semicolon terminating the statement.
    */
   Token get semicolon;
 
   /**
    * Set the semicolon terminating the statement to the given [token].
    */
   void set semicolon(Token token);
 }
 
 /**
  * The declaration of an enum constant.
  *
  * 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) =>
+      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) =>
+      new EnumDeclarationImpl(comment, metadata, enumKeyword, name, leftBracket,
+          constants, rightBracket);
+
+  /**
    * Return the enumeration constants being declared.
    */
   NodeList<EnumConstantDeclaration> get constants;
 
   @override
   ClassElement get element;
 
   /**
    * Return the 'enum' keyword.
    */
@@ skipping 26 matching lines @@
 }
 
 /**
  * An export directive.
  *
  *    exportDirective ::=
  *        [Annotation] 'export' [StringLiteral] [Combinator]* ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class ExportDirective extends NamespaceDirective {}
+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) =>
+      new ExportDirectiveImpl(comment, metadata, keyword, libraryUri,
+          configurations, combinators, semicolon);
+}
 
 /**
  * A node that represents an expression.
  *
  *    expression ::=
  *        [AssignmentExpression]
  *      | [ConditionalExpression] cascadeSection*
  *      | [ThrowExpression]
  *
  * Clients may not extend, implement or mix-in this class.
@@ skipping 92 matching lines @@
 /**
  * A function body consisting of a single expression.
  *
  *    expressionFunctionBody ::=
  *        'async'? '=>' [Expression] ';'
  *
  * 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) =>
+      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].
    */
   void set expression(Expression expression);
 
@@ skipping 28 matching lines @@
 /**
  * An expression used as a statement.
  *
  *    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) =>
+      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 11 matching lines @@
 /**
  * The "extends" clause in a class declaration.
  *
  *    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) =>
+      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 10 matching lines @@
 /**
  * The declaration of one or more fields of the same type.
  *
  *    fieldDeclaration ::=
  *        'static'? [VariableDeclarationList] ';'
  *
  * 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) =>
+      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 27 matching lines @@
  * A field formal parameter.
  *
  *    fieldFormalParameter ::=
  *        ('final' [TypeName] | 'const' [TypeName] | 'var' | [TypeName])?
  *        'this' '.' [SimpleIdentifier] ([TypeParameterList]? [FormalParameterList])?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FieldFormalParameter 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 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) =>
+      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].
    */
   void set keyword(Token token);
@@ skipping 60 matching lines @@
  * A for-each statement.
  *
  *    forEachStatement ::=
  *        'await'? 'for' '(' [DeclaredIdentifier] 'in' [Expression] ')' [Block]
  *      | 'await'? 'for' '(' [SimpleIdentifier] 'in' [Expression] ')' [Block]
  *
  * 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) =>
+      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) =>
+      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].
    */
   void set awaitKeyword(Token token);
 
@@ skipping 150 matching lines @@
  *    optionalPositionalFormalParameters ::=
  *        '[' [DefaultFormalParameter] (',' [DefaultFormalParameter])* ']'
  *
  *    namedFormalParameters ::=
  *        '{' [DefaultFormalParameter] (',' [DefaultFormalParameter])* '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FormalParameterList extends AstNode {
   /**
+   * Initialize a newly created parameter list. The list of [parameters] can be
+   * `null` if there are no parameters. The [leftDelimiter] and [rightDelimiter]
+   * can be `null` if there are no optional parameters.
+   */
+  factory FormalParameterList(
+      Token leftParenthesis,
+      List<FormalParameter> parameters,
+      Token leftDelimiter,
+      Token rightDelimiter,
+      Token rightParenthesis) = FormalParameterListImpl;
+
+  /**
    * Return the left square bracket ('[') or left curly brace ('{') introducing
    * the optional parameters, or `null` if there are no optional parameters.
    */
   Token get leftDelimiter;
 
   /**
    * Set the left square bracket ('[') or left curly brace ('{') introducing
    * the optional parameters to the given [token].
    */
   void set leftDelimiter(Token token);
@@ skipping 53 matching lines @@
  *        forInitializerStatement ';' [Expression]? ';' [Expression]?
  *
  *    forInitializerStatement ::=
  *        [DefaultFormalParameter]
  *      | [Expression]?
  *
  * 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) =>
+      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 159 matching lines @@
  *    functionDeclaration ::=
  *        'external' functionSignature
  *      | functionSignature [FunctionBody]
  *
  *    functionSignature ::=
  *        [Type]? ('get' | 'set')? [SimpleIdentifier] [FormalParameterList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 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) =>
+      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 45 matching lines @@
   void set returnType(TypeName returnType);
 }
 
 /**
  * A [FunctionDeclaration] used as a statement.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class FunctionDeclarationStatement extends Statement {
   /**
+   * Initialize a newly created function declaration statement.
+   */
+  factory FunctionDeclarationStatement(
+          FunctionDeclaration functionDeclaration) =
+      FunctionDeclarationStatementImpl;
+
+  /**
    * Return the function declaration being wrapped.
    */
   FunctionDeclaration get functionDeclaration;
 
   /**
    * Set the function declaration being wrapped to the given
    * [functionDeclaration].
    */
   void set functionDeclaration(FunctionDeclaration functionDeclaration);
 }
 
 /**
  * A function expression.
  *
  *    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) =>
+      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 37 matching lines @@
  * [MethodInvocation] nodes. Invocations of getters and setters are represented
  * by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  *
  *    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) =>
+      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
    * result of static analysis will be returned. If resolution has not been
    * performed, then `null` will be returned.
@@ skipping 51 matching lines @@
  *    functionTypeAlias ::=
  *        functionPrefix [TypeParameterList]? [FormalParameterList] ';'
  *
  *    functionPrefix ::=
  *        [TypeName]? [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 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) =>
+      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].
    */
   void set parameters(FormalParameterList parameters);
 
@@ skipping 25 matching lines @@
 /**
  * A function-typed formal parameter.
  *
  *    functionSignature ::=
  *        [TypeName]? [SimpleIdentifier] [TypeParameterList]? [FormalParameterList]
  *
  * 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,
+          {Token question: null}) =>
+      new FunctionTypedFormalParameterImpl(comment, metadata, returnType,
+          identifier, typeParameters, parameters, question);
+
+  /**
    * Return the parameters of the function-typed parameter.
    */
   FormalParameterList get parameters;
 
   /**
    * Set the parameters of the function-typed parameter to the given
    * [parameters].
    */
   void set parameters(FormalParameterList parameters);
 
@@ skipping 37 matching lines @@
  * A combinator that restricts the names being imported to those that are not in
  * a given list.
  *
  *    hideCombinator ::=
  *        'hide' [SimpleIdentifier] (',' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class HideCombinator extends Combinator {
   /**
+   * Initialize a newly created import show combinator.
+   */
+  factory HideCombinator(Token keyword, List<SimpleIdentifier> hiddenNames) =
+      HideCombinatorImpl;
+
+  /**
    * Return the list of names from the library that are hidden by this
    * combinator.
    */
   NodeList<SimpleIdentifier> get hiddenNames;
 }
 
 /**
  * A node that represents an identifier.
  *
  *    identifier ::=
@@ skipping 44 matching lines @@
 /**
  * An if statement.
  *
  *    ifStatement ::=
  *        '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) =>
+      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].
    */
   void set condition(Expression expression);
@@ skipping 66 matching lines @@
 /**
  * The "implements" clause in an class declaration.
  *
  *    implementsClause ::=
  *        'implements' [TypeName] (',' [TypeName])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ImplementsClause extends AstNode {
   /**
+   * Initialize a newly created implements clause.
+   */
+  factory ImplementsClause(Token implementsKeyword, List<TypeName> interfaces) =
+      ImplementsClauseImpl;
+
+  /**
    * Return the token representing the 'implements' keyword.
    */
   Token get implementsKeyword;
 
   /**
    * Set the token representing the 'implements' keyword to the given [token].
    */
   void set implementsKeyword(Token token);
 
   /**
@@ skipping 110 matching lines @@
     }
     // next ensure that the lists are equivalent
     if (!allHides1.toSet().containsAll(allHides2)) {
       return -1;
     }
     if (!allShows1.toSet().containsAll(allShows2)) {
       return -1;
     }
     return 0;
   };
+
+  /**
+   * 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) =>
+      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].
    */
   void set asKeyword(Token token);
@@ skipping 25 matching lines @@
  * An index expression.
  *
  *    indexExpression ::=
  *        [Expression] '[' [Expression] ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IndexExpression extends Expression
     implements MethodReferenceExpression {
   /**
+   * Initialize a newly created index expression.
+   */
+  factory IndexExpression.forCascade(Token period, Token leftBracket,
+          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) =>
+      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;
 
   /**
    * Set the auxiliary elements associated with this identifier to the given
@@ skipping 98 matching lines @@
  * An instance creation expression.
  *
  *    newExpression ::=
  *        ('new' | 'const') [TypeName] ('.' [SimpleIdentifier])? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InstanceCreationExpression extends Expression
     implements ConstructorReferenceNode {
   /**
+   * Initialize a newly created instance creation expression.
+   */
+  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 36 matching lines @@
  *        decimalDigit+
  *
  *    hexadecimalIntegerLiteral ::=
  *        '0x' hexadecimalDigit+
  *      | '0X' hexadecimalDigit+
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class IntegerLiteral extends Literal {
   /**
+   * Initialize a newly created integer literal.
+   */
+  factory IntegerLiteral(Token literal, int value) = IntegerLiteralImpl;
+
+  /**
    * Return the token representing the literal.
    */
   Token get literal;
 
   /**
    * Set the token representing the literal to the given [token].
    */
   void set literal(Token token);
 
   /**
@@ skipping 22 matching lines @@
  * An expression embedded in a string interpolation.
  *
  *    interpolationExpression ::=
  *        '$' [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) =>
+      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].
    */
   void set expression(Expression expression);
@@ skipping 27 matching lines @@
 /**
  * A non-empty substring of an interpolated string.
  *
  *    interpolationString ::=
  *        characters
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class InterpolationString extends InterpolationElement {
   /**
+   * Initialize a newly created string of characters that are part of a string
+   * interpolation.
+   */
+  factory InterpolationString(Token contents, String value) =
+      InterpolationStringImpl;
+
+  /**
    * Return the characters that will be added to the string.
    */
   Token get contents;
 
   /**
    * Set the characters that will be added to the string to the given [token].
    */
   void set contents(Token token);
 
   /**
@@ skipping 87 matching lines @@
 /**
  * An is expression.
  *
  *    isExpression ::=
  *        [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) =>
+      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].
    */
   void set expression(Expression expression);
 
@@ skipping 31 matching lines @@
 /**
  * A label on either a [LabeledStatement] or a [NamedExpression].
  *
  *    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) =>
+      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].
    */
   void set colon(Token token);
 
@@ skipping 11 matching lines @@
 /**
  * A statement that has a label associated with them.
  *
  *    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) =>
+      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;
 
   /**
    * Set the statement with which the labels are being associated to the given
    * [statement].
    */
   void set statement(Statement statement);
 }
 
 /**
  * A library directive.
  *
  *    libraryDirective ::=
  *        [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) =>
+      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 20 matching lines @@
 /**
  * The identifier for a library.
  *
  *    libraryIdentifier ::=
  *        [SimpleIdentifier] ('.' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class LibraryIdentifier extends Identifier {
   /**
+   * Initialize a newly created prefixed identifier.
+   */
+  factory LibraryIdentifier(List<SimpleIdentifier> components) =
+      LibraryIdentifierImpl;
+
+  /**
    * Return the components of the identifier.
    */
   NodeList<SimpleIdentifier> get components;
 }
 
 /**
  * A list literal.
  *
  *    listLiteral ::=
  *        'const'? ('<' [TypeName] '>')? '[' ([Expression] ','?)? ']'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ListLiteral extends TypedLiteral {
   /**
+   * Initialize a newly created list literal. The [constKeyword] can be `null`
+   * if the literal is not a constant. The [typeArguments] can be `null` if no
+   * type arguments were declared. The list of [elements] can be `null` if the
+   * list is empty.
+   */
+  factory ListLiteral(
+      Token constKeyword,
+      TypeArgumentList typeArguments,
+      Token leftBracket,
+      List<Expression> elements,
+      Token rightBracket) = ListLiteralImpl;
+
+  /**
    * Return the expressions used to compute the elements of the list.
    */
   NodeList<Expression> get elements;
 
   /**
    * Return the left square bracket.
    */
   Token get leftBracket;
 
   /**
@@ skipping 32 matching lines @@
  * A literal map.
  *
  *    mapLiteral ::=
  *        'const'? ('<' [TypeName] (',' [TypeName])* '>')?
  *        '{' ([MapLiteralEntry] (',' [MapLiteralEntry])* ','?)? '}'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MapLiteral extends TypedLiteral {
   /**
+   * Initialize a newly created map literal. The [constKeyword] can be `null` if
+   * the literal is not a constant. The [typeArguments] can be `null` if no type
+   * arguments were declared. The [entries] can be `null` if the map is empty.
+   */
+  factory MapLiteral(
+      Token constKeyword,
+      TypeArgumentList typeArguments,
+      Token leftBracket,
+      List<MapLiteralEntry> entries,
+      Token rightBracket) = MapLiteralImpl;
+
+  /**
    * Return the entries in the map.
    */
   NodeList<MapLiteralEntry> get entries;
 
   /**
    * Return the left curly bracket.
    */
   Token get leftBracket;
 
   /**
@@ skipping 15 matching lines @@
 /**
  * A single key/value pair in a map literal.
  *
  *    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) =>
+      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].
    */
   void set key(Expression string);
@@ skipping 32 matching lines @@
  *        methodName [TypeParameterList] [FormalParameterList]
  *
  *    methodName ::=
  *        [SimpleIdentifier]
  *      | 'operator' [SimpleIdentifier]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class MethodDeclaration extends ClassMember {
   /**
+   * Initialize a newly created method declaration. Either or both of the
+   * [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) =>
+      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);
 
   @override
@@ skipping 121 matching lines @@
  * [FunctionExpressionInvocation] nodes. Invocations of getters and setters are
  * represented by either [PrefixedIdentifier] or [PropertyAccess] nodes.
  *
  *    methodInvocation ::=
  *        ([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) =>
+      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].
    */
   bool get isCascaded;
@@ skipping 120 matching lines @@
  * An expression that has a name associated with it. They are used in method
  * invocations when there are named parameters.
  *
  *    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) =>
+      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.
    */
   Expression get expression;
@@ skipping 72 matching lines @@
 /**
  * The "native" clause in an class declaration.
  *
  *    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) =>
+      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].
    */
   void set name(StringLiteral name);
 
@@ skipping 12 matching lines @@
  * A function body that consists of a native keyword followed by a string
  * literal.
  *
  *    nativeFunctionBody ::=
  *        '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) =>
+      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].
    */
   void set nativeKeyword(Token token);
@@ skipping 22 matching lines @@
   void set stringLiteral(StringLiteral stringLiteral);
 }
 
 /**
  * A list of AST nodes that have a common parent.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NodeList<E extends AstNode> implements List<E> {
   /**
+   * Initialize a newly created list of nodes such that all of the nodes that
+   * are added to the list will have their parent set to the given [owner]. The
+   * list will initially be populated with the given [elements].
+   */
+  factory NodeList(AstNode owner, [List<E> elements]) =>
+      new NodeListImpl<E>(owner as AstNodeImpl, elements);
+
+  /**
    * Return the first token included in this node list's source range, or `null`
    * if the list is empty.
    */
   Token get beginToken;
 
   /**
    * Return the last token included in this node list's source range, or `null`
    * if the list is empty.
    */
   Token get endToken;
@@ skipping 73 matching lines @@
 /**
  * A null literal expression.
  *
  *    nullLiteral ::=
  *        'null'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class NullLiteral extends Literal {
   /**
+   * Initialize a newly created null literal.
+   */
+  factory NullLiteral(Token literal) = NullLiteralImpl;
+
+  /**
    * Return the token representing the literal.
    */
   Token get literal;
 
   /**
    * Set the token representing the literal to the given [token].
    */
   void set literal(Token token);
 }
 
 /**
  * A parenthesized expression.
  *
  *    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) =>
+      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 20 matching lines @@
 /**
  * A part directive.
  *
  *    partDirective ::=
  *        [Annotation] 'part' [StringLiteral] ';'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PartDirective extends UriBasedDirective {
   /**
+   * Initialize a newly created part directive. Either or both of the [comment]
+   * and [metadata] can be `null` if the directive does not have the
+   * corresponding attribute.
+   */
+  factory PartDirective(
+      Comment comment,
+      List<Annotation> metadata,
+      Token partKeyword,
+      StringLiteral partUri,
+      Token semicolon) = PartDirectiveImpl;
+
+  /**
    * Return the token representing the 'part' keyword.
    */
   Token get partKeyword;
 
   /**
    * Set the token representing the 'part' keyword to the given [token].
    */
   void set partKeyword(Token token);
 
   /**
@@ skipping 10 matching lines @@
 /**
  * A part-of directive.
  *
  *    partOfDirective ::=
  *        [Annotation] 'part' 'of' [Identifier] ';'
  *
  * 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. Only one of the [uri] and [libraryName] should be
+   * provided.
+   */
+  factory PartOfDirective(
+          Comment comment,
+          List<Annotation> metadata,
+          Token partKeyword,
+          Token ofKeyword,
+          StringLiteral uri,
+          LibraryIdentifier libraryName,
+          Token semicolon) =>
+      new PartOfDirectiveImpl(comment, metadata, partKeyword, ofKeyword, uri,
+          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].
    */
   void set libraryName(LibraryIdentifier libraryName);
@@ skipping 47 matching lines @@
  * A postfix unary expression.
  *
  *    postfixExpression ::=
  *        [Expression] [Token]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PostfixExpression extends Expression
     implements MethodReferenceExpression {
   /**
+   * Initialize a newly created postfix expression.
+   */
+  factory PostfixExpression(Expression operand, Token operator) =>
+      new PostfixExpressionImpl(operand, operator);
+
+  /**
    * Return the expression computing the operand for the operator.
    */
   Expression get operand;
 
   /**
    * Set the expression computing the operand for the operator to the given
    * [expression].
    */
   void set operand(Expression expression);
 
@@ skipping 12 matching lines @@
  * An identifier that is prefixed or an access to an object property where the
  * target of the property access is a simple identifier.
  *
  *    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) =>
+      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 33 matching lines @@
  * A prefix unary expression.
  *
  *    prefixExpression ::=
  *        [Token] [Expression]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class PrefixExpression extends Expression
     implements MethodReferenceExpression {
   /**
+   * Initialize a newly created prefix expression.
+   */
+  factory PrefixExpression(Token operator, Expression operand) =>
+      new PrefixExpressionImpl(operator, operand);
+
+  /**
    * Return the expression computing the operand for the operator.
    */
   Expression get operand;
 
   /**
    * Set the expression computing the operand for the operator to the given
    * [expression].
    */
   void set operand(Expression expression);
 
@@ skipping 15 matching lines @@
  * as [PrefixedIdentifier] nodes in cases where the target is also a simple
  * identifier.
  *
  *    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) =>
+      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.
    */
   Token get operator;
@@ skipping 42 matching lines @@
  * initialization list.
  *
  *    redirectingConstructorInvocation ::=
  *        'this' ('.' identifier)? arguments
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class RedirectingConstructorInvocation extends ConstructorInitializer
     implements ConstructorReferenceNode {
   /**
+   * 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) =>
+      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 34 matching lines @@
 /**
  * A rethrow expression.
  *
  *    rethrowExpression ::=
  *        'rethrow'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class RethrowExpression extends Expression {
   /**
+   * Initialize a newly created rethrow expression.
+   */
+  factory RethrowExpression(Token rethrowKeyword) = RethrowExpressionImpl;
+
+  /**
    * Return the token representing the 'rethrow' keyword.
    */
   Token get rethrowKeyword;
 
   /**
    * Set the token representing the 'rethrow' keyword to the given [token].
    */
   void set rethrowKeyword(Token token);
 }
 
 /**
  * A return statement.
  *
  *    returnStatement ::=
  *        '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) =>
+      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].
    */
   void set expression(Expression expression);
@@ skipping 22 matching lines @@
 /**
  * A script tag that can optionally occur at the beginning of a compilation unit.
  *
  *    scriptTag ::=
  *        '#!' (~NEWLINE)* NEWLINE
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ScriptTag extends AstNode {
   /**
+   * Initialize a newly created script tag.
+   */
+  factory ScriptTag(Token scriptTag) = ScriptTagImpl;
+
+  /**
    * Return the token representing this script tag.
    */
   Token get scriptTag;
 
   /**
    * Set the token representing this script tag to the given [token].
    */
   void set scriptTag(Token token);
 }
 
 /**
  * A combinator that restricts the names being imported to those in a given list.
  *
  *    showCombinator ::=
  *        'show' [SimpleIdentifier] (',' [SimpleIdentifier])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ShowCombinator extends Combinator {
   /**
+   * Initialize a newly created import show combinator.
+   */
+  factory ShowCombinator(Token keyword, List<SimpleIdentifier> shownNames) =
+      ShowCombinatorImpl;
+
+  /**
    * Return the list of names from the library that are made visible by this
    * combinator.
    */
   NodeList<SimpleIdentifier> get shownNames;
 }
 
 /**
  * A simple formal parameter.
  *
  *    simpleFormalParameter ::=
  *        ('final' [TypeName] | 'var' | [TypeName])? [SimpleIdentifier]
  *
  * 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) =>
+      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].
    */
   void set keyword(Token token);
@@ skipping 17 matching lines @@
  *        initialCharacter internalCharacter*
  *
  *    initialCharacter ::= '_' | '$' | letter
  *
  *    internalCharacter ::= '_' | '$' | letter | digit
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleIdentifier extends Identifier {
   /**
+   * Initialize a newly created identifier.
+   */
+  factory SimpleIdentifier(Token token, {bool isDeclaration: false}) {
+    if (isDeclaration) {
+      return new DeclaredSimpleIdentifier(token);
+    }
+    return new SimpleIdentifierImpl(token);
+  }
+
+  /**
    * 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;
 
   /**
    * Set the auxiliary elements associated with this identifier to the given
@@ skipping 77 matching lines @@
  *      | '"""' characters '"""'
  *
  *    singleLineStringLiteral ::=
  *        "'" characters "'"
  *      | '"' characters '"'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SimpleStringLiteral extends SingleStringLiteral {
   /**
+   * Initialize a newly created simple string literal.
+   */
+  factory SimpleStringLiteral(Token literal, String value) =
+      SimpleStringLiteralImpl;
+
+  /**
    * Return the token representing the literal.
    */
   Token get literal;
 
   /**
    * Set the token representing the literal to the given [token].
    */
   void set literal(Token token);
 
   /**
@@ skipping 78 matching lines @@
  * A string interpolation literal.
  *
  *    stringInterpolation ::=
  *        ''' [InterpolationElement]* '''
  *      | '"' [InterpolationElement]* '"'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class StringInterpolation extends SingleStringLiteral {
   /**
+   * Initialize a newly created string interpolation expression.
+   */
+  factory StringInterpolation(List<InterpolationElement> elements) =
+      StringInterpolationImpl;
+
+  /**
    * Return the elements that will be composed to produce the resulting string.
    */
   NodeList<InterpolationElement> get elements;
 }
 
 /**
  * A string literal expression.
  *
  *    stringLiteral ::=
  *        [SimpleStringLiteral]
@@ skipping 15 matching lines @@
  * initialization list.
  *
  *    superInvocation ::=
  *        'super' ('.' [SimpleIdentifier])? [ArgumentList]
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SuperConstructorInvocation extends ConstructorInitializer
     implements ConstructorReferenceNode {
   /**
+   * 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) =>
+      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 34 matching lines @@
 /**
  * A super expression.
  *
  *    superExpression ::=
  *        'super'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SuperExpression extends Expression {
   /**
+   * Initialize a newly created super expression.
+   */
+  factory SuperExpression(Token superKeyword) = SuperExpressionImpl;
+
+  /**
    * Return the token representing the 'super' keyword.
    */
   Token get superKeyword;
 
   /**
    * Set the token representing the 'super' keyword to the given [token].
    */
   void set superKeyword(Token token);
 }
 
 /**
  * A case in a switch statement.
  *
  *    switchCase ::=
  *        [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) =>
+      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].
    */
   void set expression(Expression expression);
 }
 
 /**
  * The default case in a switch statement.
  *
  *    switchDefault ::=
  *        [SimpleIdentifier]* 'default' ':' [Statement]*
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class SwitchDefault extends SwitchMember {}
+abstract class SwitchDefault extends SwitchMember {
+  /**
+   * Initialize a newly created switch default. The list of [labels] can be
+   * `null` if there are no labels.
+   */
+  factory SwitchDefault(List<Label> labels, Token keyword, Token colon,
+      List<Statement> statements) = SwitchDefaultImpl;
+}
 
 /**
  * An element within a switch statement.
  *
  *    switchMember ::=
  *        switchCase
  *      | switchDefault
  *
  * Clients may not extend, implement or mix-in this class.
  */
@@ skipping 36 matching lines @@
 /**
  * A switch statement.
  *
  *    switchStatement ::=
  *        '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) =>
+      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].
    */
   void set expression(Expression expression);
@@ skipping 57 matching lines @@
 /**
  * A symbol literal expression.
  *
  *    symbolLiteral ::=
  *        '#' (operator | (identifier ('.' identifier)*))
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class SymbolLiteral extends Literal {
   /**
+   * Initialize a newly created symbol literal.
+   */
+  factory SymbolLiteral(Token poundSign, List<Token> components) =
+      SymbolLiteralImpl;
+
+  /**
    * Return the components of the literal.
    */
   List<Token> get components;
 
   /**
    * Return the token introducing the literal.
    */
   Token get poundSign;
 
   /**
    * Set the token introducing the literal to the given [token].
    */
   void set poundSign(Token token);
 }
 
 /**
  * A this expression.
  *
  *    thisExpression ::=
  *        'this'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class ThisExpression extends Expression {
   /**
+   * Initialize a newly created this expression.
+   */
+  factory ThisExpression(Token thisKeyword) = ThisExpressionImpl;
+
+  /**
    * Return the token representing the 'this' keyword.
    */
   Token get thisKeyword;
 
   /**
    * Set the token representing the 'this' keyword to the given [token].
    */
   void set thisKeyword(Token token);
 }
 
 /**
  * A throw expression.
  *
  *    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) =>
+      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].
    */
   void set expression(Expression expression);
 
@@ skipping 12 matching lines @@
  * The declaration of one or more top-level variables of the same type.
  *
  *    topLevelVariableDeclaration ::=
  *        ('final' | 'const') type? staticFinalDeclarationList ';'
  *      | variableDeclaration ';'
  *
  * 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) =>
+      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 14 matching lines @@
  *    tryStatement ::=
  *        'try' [Block] ([CatchClause]+ finallyClause? | finallyClause)
  *
  *    finallyClause ::=
  *        'finally' [Block]
  *
  * 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) =>
+      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 71 matching lines @@
 /**
  * A list of type arguments.
  *
  *    typeArguments ::=
  *        '<' typeName (',' typeName)* '>'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeArgumentList extends AstNode {
   /**
+   * Initialize a newly created list of type arguments.
+   */
+  factory TypeArgumentList(
+          Token leftBracket, List<TypeName> arguments, Token rightBracket) =
+      TypeArgumentListImpl;
+
+  /**
    * Return the type arguments associated with the type.
    */
   NodeList<TypeName> get arguments;
 
   /**
    * Return the left bracket.
    */
   Token get leftBracket;
 
   /**
@@ skipping 49 matching lines @@
 /**
  * The name of a type, which can optionally include type arguments.
  *
  *    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,
+          {Token question: null}) =>
+      new TypeNameImpl(name, typeArguments, question);
+
+  /**
    * 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;
 
   /**
    * Return the name of the type.
    */
@@ skipping 43 matching lines @@
 /**
  * A type parameter.
  *
  *    typeParameter ::=
  *        [SimpleIdentifier] ('extends' [TypeName])?
  *
  * 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) =>
+      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].
    */
   void set bound(TypeName typeName);
@@ skipping 23 matching lines @@
 /**
  * Type parameters within a declaration.
  *
  *    typeParameterList ::=
  *        '<' [TypeParameter] (',' [TypeParameter])* '>'
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeParameterList extends AstNode {
   /**
+   * Initialize a newly created list of type parameters.
+   */
+  factory TypeParameterList(
+      Token leftBracket,
+      List<TypeParameter> typeParameters,
+      Token rightBracket) = TypeParameterListImpl;
+
+  /**
    * Return the left angle bracket.
    */
   Token get leftBracket;
 
   /**
    * Return the right angle bracket.
    */
   Token get rightBracket;
 
   /**
@@ skipping 72 matching lines @@
  *        [SimpleIdentifier] ('=' [Expression])?
  *
  * TODO(paulberry): the grammar does not allow metadata to be associated with
  * a VariableDeclaration, and currently we don't record comments for it either.
  * Consider changing the class hierarchy so that [VariableDeclaration] does not
  * 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) =>
+      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 46 matching lines @@
  *    finalConstVarOrType ::=
  *      | 'final' [TypeName]?
  *      | 'const' [TypeName]?
  *      | 'var'
  *      | [TypeName]
  *
  * 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) =>
+      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
    * `false` even though they are implicitly final. (In other words, this is a
    * syntactic check rather than a semantic check.)
@@ skipping 33 matching lines @@
  * A list of variables that are being declared in a context where a statement is
  * required.
  *
  *    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) =>
+      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 10 matching lines @@
 /**
  * A while statement.
  *
  *    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) =>
+      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 42 matching lines @@
 /**
  * The with clause in a class declaration.
  *
  *    withClause ::=
  *        'with' [TypeName] (',' [TypeName])*
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class WithClause extends AstNode {
   /**
+   * Initialize a newly created with clause.
+   */
+  factory WithClause(Token withKeyword, List<TypeName> mixinTypes) =
+      WithClauseImpl;
+
+  /**
    * Return the names of the mixins that were specified.
    */
   NodeList<TypeName> get mixinTypes;
 
   /**
    * Return the token representing the 'with' keyword.
    */
   Token get withKeyword;
 
   /**
    * Set the token representing the 'with' keyword to the given [token].
    */
   void set withKeyword(Token token);
 }
 
 /**
  * A yield statement.
  *
  *    yieldStatement ::=
  *        '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) =>
+      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 19 matching lines @@
   /**
    * Return the 'yield' keyword.
    */
   Token get yieldKeyword;
 
   /**
    * Return the 'yield' keyword to the given [token].
    */
   void set yieldKeyword(Token token);
 }