Add support for the new function-type syntax.

Fixes #27967
BUG= http://dartbug.com/27967
[email protected]

Committed: 85227ba

Reverted: f5fc210
Review-Url: https://codereview.chromium.org/2567133002 .

Author: floitschG

pkg/compiler/lib/src/common/resolution.dart

@@ -6,7 +6,6 @@ library dart2js.common.resolution;
 
 import '../common.dart';
 import '../compile_time_constants.dart';
-import '../compiler.dart' show Compiler;
 import '../constants/expressions.dart' show ConstantExpression;
 import '../constants/values.dart' show ConstantValue;
 import '../core_types.dart' show CommonElements;

pkg/compiler/lib/src/elements/elements.dart

@@ -1113,6 +1113,9 @@ abstract class FormalElement extends Element
   FunctionTypedElement get functionDeclaration;
 
   VariableDefinitions get node;
+
+  /// Whether the parameter is unnamed in a function type.
+  bool get isUnnamed;
 }
 
 /// A formal parameter of a function or constructor.

pkg/compiler/lib/src/elements/modelx.dart

@@ -1345,7 +1345,7 @@ class TypedefElementX extends ElementX
   ResolutionTypedefType computeType(Resolution resolution) {
     if (thisTypeCache != null) return thisTypeCache;
     Typedef node = parseNode(resolution.parsingContext);
-    setThisAndRawTypes(createTypeVariables(node.typeParameters));
+    setThisAndRawTypes(createTypeVariables(node.templateParameters));
     ensureResolved(resolution);
     return thisTypeCache;
   }
@@ -1743,6 +1743,15 @@ class FormalElementX extends ElementX
       : this.identifier = identifier,
         super(identifier.source, elementKind, enclosingElement);
 
+  FormalElementX.unnamed(ElementKind elementKind,
+      FunctionTypedElement enclosingElement,
+      this.definitions)
+      : this.identifier = null,
+        super("<unnamed>", elementKind, enclosingElement);
+
+  /// Whether this is an unnamed parameter in a Function type.
+  bool get isUnnamed => identifier == null;
+
   FunctionTypedElement get functionDeclaration => enclosingElement;
 
   Modifiers get modifiers => definitions.modifiers;

pkg/compiler/lib/src/elements/resolution_types.dart

@@ -642,6 +642,16 @@ class ResolutionFunctionType extends ResolutionDartType
         optionalParameterTypes, namedParameters, namedParameterTypes);
   }
 
+  factory ResolutionFunctionType.generalized(
+      ResolutionDartType returnType,
+      List<ResolutionDartType> parameterTypes,
+      List<ResolutionDartType> optionalParameterTypes,
+      List<String> namedParameters,
+      List<ResolutionDartType> namedParameterTypes) {
+    return new ResolutionFunctionType.internal(null, returnType, parameterTypes,
+        optionalParameterTypes, namedParameters, namedParameterTypes);
+  }
+
   ResolutionFunctionType.internal(FunctionTypedElement this.element,
       [ResolutionDartType returnType = const ResolutionDynamicType(),
       List<ResolutionDartType> parameterTypes = const <ResolutionDartType>[],

pkg/compiler/lib/src/js_backend/no_such_method_registry.dart

@@ -219,7 +219,8 @@ class NoSuchMethodRegistry {
     }
     if (expr is Send && expr.isTypeCast) {
       Send sendExpr = expr;
-      var typeName = sendExpr.typeAnnotationFromIsCheckOrCast.typeName;
+      var typeAnnotation = sendExpr.typeAnnotationFromIsCheckOrCast;
+      var typeName = typeAnnotation.asNominalTypeAnnotation()?.typeName;
       if (typeName is Identifier && typeName.source == "dynamic") {
         expr = sendExpr.receiver;
       }

pkg/compiler/lib/src/kernel/kernel_visitor.dart

@@ -104,6 +104,7 @@ import '../tree/tree.dart'
         ForIn,
         FunctionDeclaration,
         FunctionExpression,
+        FunctionTypeAnnotation,
         Identifier,
         If,
         Label,
@@ -122,6 +123,7 @@ import '../tree/tree.dart'
         NewExpression,
         Node,
         NodeList,
+        NominalTypeAnnotation,
         Operator,
         ParenthesizedExpression,
         RedirectingFactoryBody,
@@ -1087,14 +1089,28 @@ class KernelVisitor extends Object
 
   @override
   visitTypeAnnotation(TypeAnnotation node) {
-    // Shouldn't be called, as the resolver have already resolved types and
+    // Shouldn't be called, as the resolver has already resolved types and
     // created [DartType] objects.
     return internalError(node, "TypeAnnotation");
   }
 
+  @override
+  visitNominalTypeAnnotation(NominalTypeAnnotation node) {
+    // Shouldn't be called, as the resolver has already resolved types and
+    // created [DartType] objects.
+    return internalError(node, "NominalTypeAnnotation");
+  }
+
+  @override
+  visitFunctionTypeAnnotation(FunctionTypeAnnotation node) {
+    // Shouldn't be called, as the resolver has already resolved types and
+    // created [DartType] objects.
+    return internalError(node, "FunctionTypeAnnotation");
+  }
+
   @override
   visitTypeVariable(TypeVariable node) {
-    // Shouldn't be called, as the resolver have already resolved types and
+    // Shouldn't be called, as the resolver has already resolved types and
     // created [DartType] objects.
     return internalError(node, "TypeVariable");
   }

pkg/compiler/lib/src/native/behavior.dart

@@ -257,7 +257,7 @@ class NativeBehavior {
   ///    Each tag kind (including the 'type-tag's) can only occur once in the
   ///    sequence.
   ///
-  /// [specString] is the specification string, [resolveType] resolves named
+  /// [specString] is the specification string, [lookupType] resolves named
   /// types into type values, [typesReturned] and [typesInstantiated] collects
   /// the types defined by the specification string, and [objectType] and
   /// [nullType] define the types for `Object` and `Null`, respectively. The

pkg/compiler/lib/src/parser/element_listener.dart

@@ -260,10 +260,17 @@ class ElementListener extends Listener {
     }
   }
 
-  void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
-    popNode(); // TODO(karlklose): do not throw away typeVariables.
-    Identifier name = popNode();
-    popNode(); // returnType
+  void endTypedef(Token typedefKeyword, Token equals, Token endToken) {
+    Identifier name;
+    if (equals == null) {
+      popNode(); // TODO(karlklose): do not throw away typeVariables.
+      name = popNode();
+      popNode(); // returnType
+    } else {
+      popNode();  // Function type.
+      popNode();  // TODO(karlklose): do not throw away typeVariables.
+      name = popNode();
+    }
     pushElement(new PartialTypedefElement(
         name.source, compilationUnitElement, typedefKeyword, endToken));
     rejectBuiltInIdentifier(name);
@@ -294,12 +301,12 @@ class ElementListener extends Listener {
 
   void endMixinApplication() {
     NodeList mixins = popNode();
-    TypeAnnotation superclass = popNode();
+    NominalTypeAnnotation superclass = popNode();
     pushNode(new MixinApplication(superclass, mixins));
   }
 
   void handleVoidKeyword(Token token) {
-    pushNode(new TypeAnnotation(new Identifier(token), null));
+    pushNode(new NominalTypeAnnotation(new Identifier(token), null));
   }
 
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
@@ -366,7 +373,7 @@ class ElementListener extends Listener {
   }
 
   void endTypeVariable(Token token, Token extendsOrSuper) {
-    TypeAnnotation bound = popNode();
+    NominalTypeAnnotation bound = popNode();
     Identifier name = popNode();
     pushNode(new TypeVariable(name, extendsOrSuper, bound));
     rejectBuiltInIdentifier(name);
@@ -391,7 +398,17 @@ class ElementListener extends Listener {
   void endType(Token beginToken, Token endToken) {
     NodeList typeArguments = popNode();
     Expression typeName = popNode();
-    pushNode(new TypeAnnotation(typeName, typeArguments));
+    pushNode(new NominalTypeAnnotation(typeName, typeArguments));
+  }
+
+  void handleNoName(Token token) {
+    pushNode(null);
+  }
+
+  void endFunctionType(Token functionToken, Token endToken) {
+    popNode();  // Type parameters.
+    popNode();  // Return type.
+    pushNode(null);
   }
 
   void handleParenthesizedExpression(BeginGroupToken token) {

pkg/compiler/lib/src/parser/listener.dart

@@ -130,9 +130,9 @@ class Listener {
 
   void endFunctionName(Token token) {}
 
-  void beginFunctionTypeAlias(Token token) {}
+  void beginTypedef(Token token) {}
 
-  void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {}
+  void endTypedef(Token typedefKeyword, Token equals, Token endToken) {}
 
   void beginMixinApplication(Token token) {}
 
@@ -295,6 +295,10 @@ class Listener {
 
   void endType(Token beginToken, Token endToken) {}
 
+  void handleNoName(Token token) {}
+
+  void endFunctionType(Token functionToken, Token endToken) {}
+
   void beginTypeArguments(Token token) {}
 
   void endTypeArguments(int count, Token beginToken, Token endToken) {}

pkg/compiler/lib/src/parser/node_listener.dart

@@ -12,7 +12,6 @@ import '../tokens/token.dart' show ErrorToken, StringToken, Token;
 import '../tree/tree.dart';
 import '../util/util.dart' show Link;
 import 'element_listener.dart' show ElementListener, ScannerOptions;
-import 'partial_elements.dart' show PartialFunctionElement;
 
 class NodeListener extends ElementListener {
   NodeListener(ScannerOptions scannerOptions, DiagnosticReporter reporter,
@@ -115,13 +114,58 @@ class NodeListener extends ElementListener {
     pushNode(makeNodeList(count, null, null, '\n'));
   }
 
-  void endFunctionTypeAlias(Token typedefKeyword, Token endToken) {
+  void endTypedef(Token typedefKeyword, Token equals, Token endToken) {
+    bool isGeneralizedTypeAlias;
+    NodeList templateParameters;
+    TypeAnnotation returnType;
+    Identifier name;
+    NodeList typeParameters;
+    NodeList formals;
+    if (equals == null) {
+      isGeneralizedTypeAlias = false;
+      formals = popNode();
+      templateParameters = popNode();
+      name = popNode();
+      returnType = popNode();
+    } else {
+      // TODO(floitsch): keep using the `FunctionTypeAnnotation' node.
+      isGeneralizedTypeAlias = true;
+      Node type = popNode();
+      if (type.asFunctionTypeAnnotation() == null) {
+        // TODO(floitsch): The parser should diagnose this problem, not
+        // this listener.
+        // However, this problem goes away, when we allow aliases for
+        // non-function types too.
+        reportFatalError(type, 'Expected a function type.');
+      }
+      FunctionTypeAnnotation functionType = type;
+      templateParameters = popNode();
+      name = popNode();
+      returnType = functionType.returnType;
+      typeParameters = functionType.typeParameters;
+      formals = functionType.formals;
+    }
+    pushNode(new Typedef(
+        isGeneralizedTypeAlias,
+        templateParameters,
+        returnType,
+        name,
+        typeParameters,
+        formals,
+        typedefKeyword,
+        endToken));
+  }
+
+  void handleNoName(Token token) {
+    pushNode(null);
+  }
+
+  void endFunctionType(Token functionToken, Token endToken) {
     NodeList formals = popNode();
     NodeList typeParameters = popNode();
-    Identifier name = popNode();
     TypeAnnotation returnType = popNode();
-    pushNode(new Typedef(
-        returnType, name, typeParameters, formals, typedefKeyword, endToken));
+    pushNode(new FunctionTypeAnnotation(
+        returnType, functionToken, typeParameters, formals));
   }
 
   void endNamedMixinApplication(
@@ -206,7 +250,7 @@ class NodeListener extends ElementListener {
     NodeList typeArguments = popNode();
     Node classReference = popNode();
     if (typeArguments != null) {
-      classReference = new TypeAnnotation(classReference, typeArguments);
+      classReference = new NominalTypeAnnotation(classReference, typeArguments);
     } else {
       Identifier identifier = classReference.asIdentifier();
       Send send = classReference.asSend();
@@ -791,7 +835,7 @@ class NodeListener extends ElementListener {
       NodeList typeArguments = popNode();
       Node receiver = popNode();
       if (typeArguments != null) {
-        receiver = new TypeAnnotation(receiver, typeArguments);
+        receiver = new NominalTypeAnnotation(receiver, typeArguments);
         recoverableError(typeArguments, 'Type arguments are not allowed here.');
       } else {
         Identifier identifier = receiver.asIdentifier();