Parse factory constructors with Fasta.

pkg/front_end/lib/src/fasta/analyzer/ast_builder.dart

 // Copyright (c) 2016, 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.
 
 library fasta.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
@@ skipping 553 matching lines @@
   void handleConditionalExpression(Token question, Token colon) {
     debugEvent("ConditionalExpression");
     Expression elseExpression = pop();
     Expression thenExpression = pop();
     Expression condition = pop();
     push(ast.conditionalExpression(condition, toAnalyzerToken(question),
         thenExpression, toAnalyzerToken(colon), elseExpression));
   }
 
   @override
+  void endRedirectingFactoryBody(Token equalToken, Token endToken) {
+    debugEvent("RedirectingFactoryBody");
+    ConstructorName constructorName = pop();
+    Token starToken = pop();
+    Token asyncToken = pop();
+    push(new _RedirectingFactoryBody(
+        asyncToken, starToken, equalToken, constructorName));
+  }
+
+  @override
   void endRethrowStatement(Token rethrowToken, Token endToken) {
     debugEvent("RethrowStatement");
     RethrowExpression expression =
         ast.rethrowExpression(toAnalyzerToken(rethrowToken));
     // TODO(scheglov) According to the specification, 'rethrow' is a statement.
     push(ast.expressionStatement(expression, toAnalyzerToken(endToken)));
   }
 
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
@@ skipping 582 matching lines @@
     push(ast.functionExpression(typeParameters, parameters, body));
   }
 
   @override
   void handleNoFieldInitializer(Token token) {
     debugEvent("NoFieldInitializer");
     SimpleIdentifier name = pop();
     push(ast.variableDeclaration(name, null, null));
   }
 
+  @override
+  void endFactoryMethod(
+      Token beginToken, Token factoryKeyword, Token semicolon) {
+    debugEvent("FactoryMethod");
+
+    FunctionBody body;
+    Token separator;
+    ConstructorName redirectedConstructor;
+    Object bodyObject = pop();
+    if (bodyObject is FunctionBody) {
+      body = bodyObject;
+    } else if (bodyObject is _RedirectingFactoryBody) {
+      separator = bodyObject.equalToken;
+      redirectedConstructor = bodyObject.constructorName;
+      body = ast.emptyFunctionBody(toAnalyzerToken(semicolon));
+    } else {
+      internalError('Unexpected body object: ${bodyObject.runtimeType}');
+    }
+
+    FormalParameterList parameters = pop();
+    ConstructorName constructorName = pop();
+    _Modifiers modifiers = pop();
+    List<Annotation> metadata = pop();
+    Comment comment = pop();
+    push(ast.constructorDeclaration(
+        comment,
+        metadata,
+        toAnalyzerToken(modifiers?.externalKeyword),
+        toAnalyzerToken(modifiers?.finalConstOrVarKeyword),
+        toAnalyzerToken(factoryKeyword),
+        constructorName.type.name,
+        constructorName.period,
+        constructorName.name,
+        parameters,
+        toAnalyzerToken(separator),
+        null,
+        redirectedConstructor,
+        body));
+  }
+
   void endFieldInitializer(Token assignment) {
     debugEvent("FieldInitializer");
     Expression initializer = pop();
     SimpleIdentifier name = pop();
     push(ast.variableDeclaration(
         name, toAnalyzerToken(assignment), initializer));
   }
 
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("TopLevelFields");
@@ skipping 277 matching lines @@
 
 /// Data structure placed on the stack to represent the default parameter
 /// value with the separator token.
 class _ParameterDefaultValue {
   final Token separator;
   final Expression value;
 
   _ParameterDefaultValue(this.separator, this.value);
 }
 
+/// Data structure placed on stack to represent the redirected constructor.
+class _RedirectingFactoryBody {
+  final Token asyncKeyword;
+  final Token starKeyword;
+  final Token equalToken;
+  final ConstructorName constructorName;
+
+  _RedirectingFactoryBody(this.asyncKeyword, this.starKeyword, this.equalToken,
+      this.constructorName);
+}
+
 /// Data structure placed on the stack as a container for optional parameters.
 class _OptionalFormalParameters {
   final List<FormalParameter> parameters;
   final Token leftDelimiter;
   final Token rightDelimiter;
 
   _OptionalFormalParameters(
       this.parameters, this.leftDelimiter, this.rightDelimiter);
 }
 
@@ skipping 31 matching lines @@
       } else if (identical('static', s)) {
         staticKeyword = token;
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }