Support generic method syntax in kernel pipeline.

pkg/kernel/lib/analyzer/ast_from_analyzer.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 kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 382 matching lines @@
 
   List<ast.DartType> buildOptionalTypeArgumentList(TypeArgumentList node) {
     if (node == null) return null;
     return _typeBuilder.buildList(node.arguments);
   }
 
   List<ast.DartType> buildTypeArgumentList(TypeArgumentList node) {
     return _typeBuilder.buildList(node.arguments);
   }
 
-  List<ast.TypeParameter> buildOptionalTypeParameterList(
-      TypeParameterList node) {
+  List<ast.TypeParameter> buildOptionalTypeParameterList(TypeParameterList node,
+      {bool strongModeOnly: false}) {
     if (node == null) return <ast.TypeParameter>[];
+    if (strongModeOnly && !strongMode) return <ast.TypeParameter>[];
     return node.typeParameters.map(buildTypeParameter).toList();
   }
 
   ast.TypeParameter buildTypeParameter(TypeParameter node) {
     return makeTypeParameter(node.element,
         bound: buildOptionalTypeAnnotation(node.bound) ??
             defaultTypeParameterBound);
   }
 
   ConstructorElement findDefaultConstructor(ClassElement class_) {
     for (var constructor in class_.constructors) {
       // Note: isDefaultConstructor checks if the constructor is suitable for
       // being invoked without arguments.  It does not imply that it is
       // synthetic.
       if (constructor.isDefaultConstructor && !constructor.isFactory) {
         return constructor;
       }
     }
     return null;
   }
 
   ast.FunctionNode buildFunctionInterface(FunctionTypedElement element) {
     var positional = <ast.VariableDeclaration>[];
     var named = <ast.VariableDeclaration>[];
     int requiredParameterCount = 0;
     // Initialize type parameters in two passes: put them into scope,
     // and compute the bounds afterwards while they are all in scope.
     var typeParameters = <ast.TypeParameter>[];
-    for (var parameter in element.typeParameters) {
-      var parameterNode = new ast.TypeParameter(parameter.name);
-      typeParameters.add(parameterNode);
-      localTypeParameters[parameter] = parameterNode;
+    if (strongMode || element is ConstructorElement) {
+      for (var parameter in element.typeParameters) {
+        var parameterNode = new ast.TypeParameter(parameter.name);
+        typeParameters.add(parameterNode);
+        localTypeParameters[parameter] = parameterNode;
+      }
     }
     for (int i = 0; i < typeParameters.length; ++i) {
       var parameter = element.typeParameters[i];
       var parameterNode = typeParameters[i];
       parameterNode.bound = parameter.bound == null
           ? defaultTypeParameterBound
           : buildType(parameter.bound);
     }
     for (var parameter in element.parameters) {
       var parameterNode = new ast.VariableDeclaration(parameter.name,
@@ skipping 825 matching lines @@
 
   ast.Statement visitFunctionDeclarationStatement(
       FunctionDeclarationStatement node) {
     var declaration = node.functionDeclaration;
     var expression = declaration.functionExpression;
     LocalElement element = declaration.element as dynamic; // Cross cast.
     // TODO: Set a function type on the variable.
     return new ast.FunctionDeclaration(
         scope.makeVariableDeclaration(element),
         scope.buildFunctionNode(expression.parameters, expression.body,
-            typeParameters:
-                scope.buildOptionalTypeParameterList(expression.typeParameters),
+            typeParameters: scope.buildOptionalTypeParameterList(
+                expression.typeParameters,
+                strongModeOnly: true),
             returnType: declaration.returnType));
   }
 
   @override
   visitStatement(Statement node) {
     return scope.internalError('Unhandled statement ${node.runtimeType}');
   }
 }
 
 class ExpressionBuilder
@@ skipping 173 matching lines @@
     return new ast.ConditionalExpression(
         build(node.condition),
         build(node.thenExpression),
         build(node.elseExpression),
         scope.getInferredType(node));
   }
 
   ast.Expression visitFunctionExpression(FunctionExpression node) {
     return new ast.FunctionExpression(scope.buildFunctionNode(
         node.parameters, node.body,
-        typeParameters:
-            scope.buildOptionalTypeParameterList(node.typeParameters),
+        typeParameters: scope.buildOptionalTypeParameterList(
+            node.typeParameters,
+            strongModeOnly: true),
         inferredReturnType: scope.getInferredReturnType(node)));
   }
 
   ast.Arguments buildArguments(ArgumentList valueArguments,
       {TypeArgumentList explicitTypeArguments,
       List<ast.DartType> inferTypeArguments()}) {
     var positional = <ast.Expression>[];
     var named = <ast.NamedExpression>[];
     for (var argument in valueArguments.arguments) {
       if (argument is NamedExpression) {
         named.add(new ast.NamedExpression(
             argument.name.label.name, build(argument.expression)));
       } else if (named.isNotEmpty) {
         return scope.emitCompileTimeError(
             ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT);
       } else {
         positional.add(build(argument));
       }
     }
     List<ast.DartType> typeArguments;
     if (explicitTypeArguments != null) {
       typeArguments = scope.buildTypeArgumentList(explicitTypeArguments);
     } else if (inferTypeArguments != null) {
       typeArguments = inferTypeArguments();
     }
     return new ast.Arguments(positional, named: named, types: typeArguments);
   }
 
   ast.Arguments buildArgumentsForInvocation(InvocationExpression node) {
-    return buildArguments(node.argumentList,
-        explicitTypeArguments: node.typeArguments,
-        inferTypeArguments: () =>
-            scope.getInferredInvocationTypeArguments(node));
+    if (scope.strongMode) {
+      return buildArguments(node.argumentList,
+          explicitTypeArguments: node.typeArguments,
+          inferTypeArguments: () =>
+              scope.getInferredInvocationTypeArguments(node));
+    } else {
+      return buildArguments(node.argumentList);
+    }
   }
 
   static final ast.Name callName = new ast.Name('call');
 
   ast.Expression visitFunctionExpressionInvocation(
       FunctionExpressionInvocation node) {
     return new ast.MethodInvocation(
         build(node.function),
         callName,
         buildArgumentsForInvocation(node),
@@ skipping 567 matching lines @@
   /// to an [ast.DartType].
   ast.DartType buildClosedTypeFromDartType(DartType type) {
     return convertType(type, <TypeParameterElement>[]);
   }
 
   /// Convert to an [ast.DartType] and keep type variables.
   ast.DartType buildFromDartType(DartType type) {
     return convertType(type, null);
   }
 
+  /// True if [parameter] should not be reified, because spec mode does not
+  /// currently reify generic method type parameters.
+  bool isUnreifiedTypeParameter(TypeParameterElement parameter) {
+    return !scope.strongMode && parameter.enclosingElement is! ClassElement;
+  }
+
   /// Converts [type] to an [ast.DartType], while replacing unbound type
   /// variables with 'dynamic'.
   ///
   /// If [boundVariables] is null, no type variables are replaced, otherwise all
   /// type variables except those in [boundVariables] are replaced.  In other
   /// words, it represents the bound variables, or "all variables" if omitted.
   ast.DartType convertType(
       DartType type, List<TypeParameterElement> boundVariables) {
     if (type is TypeParameterType) {
+      if (isUnreifiedTypeParameter(type.element)) {
+        return const ast.DynamicType();
+      }
       if (boundVariables == null || boundVariables.contains(type)) {
         var typeParameter = scope.getTypeParameterReference(type.element);
         if (!scope.allowClassTypeParameters &&
             typeParameter.parent is ast.Class) {
           return const ast.InvalidType();
         }
         return new ast.TypeParameterType(typeParameter);
       } else {
         return const ast.DynamicType();
       }
@@ skipping 88 matching lines @@
       case ElementKind.FUNCTION_TYPE_ALIAS:
         FunctionTypeAliasElement functionType = element;
         return buildClosedTypeFromDartType(functionType.type);
 
       case ElementKind.TYPE_PARAMETER:
         var typeParameter = scope.getTypeParameterReference(element);
         if (!scope.allowClassTypeParameters &&
             typeParameter.parent is ast.Class) {
           return const ast.InvalidType();
         }
+        if (isUnreifiedTypeParameter(element)) {
+          return const ast.DynamicType();
+        }
         return new ast.TypeParameterType(typeParameter);
 
       case ElementKind.COMPILATION_UNIT:
       case ElementKind.CONSTRUCTOR:
       case ElementKind.EXPORT:
       case ElementKind.IMPORT:
       case ElementKind.LABEL:
       case ElementKind.LIBRARY:
       case ElementKind.PREFIX:
       case ElementKind.UNIVERSE:
@@ skipping 464 matching lines @@
     }
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     addAnnotations(node.metadata);
     ast.Procedure procedure = currentMember;
     procedure.function = scope.buildFunctionNode(node.parameters, node.body,
         returnType: node.returnType,
         inferredReturnType: scope.buildType(
             resolutionMap.elementDeclaredByMethodDeclaration(node).returnType),
-        typeParameters:
-            scope.buildOptionalTypeParameterList(node.typeParameters))
-      ..parent = procedure;
+        typeParameters: scope.buildOptionalTypeParameterList(
+            node.typeParameters,
+            strongModeOnly: true))..parent = procedure;
     handleNativeBody(node.body);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     addAnnotations(node.metadata);
     ast.Field field = currentMember;
     field.type = scope.buildType(
         resolutionMap.elementDeclaredByVariableDeclaration(node).type);
     if (node.initializer != null) {
       field.initializer = scope.buildTopLevelExpression(node.initializer)
         ..parent = field;
     } else if (field.isStatic) {
       // Add null initializer to static fields without an initializer.
       // For instance fields, this is handled when building the class.
       field.initializer = new ast.NullLiteral()..parent = field;
     }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     var function = node.functionExpression;
     ast.Procedure procedure = currentMember;
     procedure.function = scope.buildFunctionNode(
         function.parameters, function.body,
         returnType: node.returnType,
-        typeParameters:
-            scope.buildOptionalTypeParameterList(function.typeParameters))
-      ..parent = procedure;
+        typeParameters: scope.buildOptionalTypeParameterList(
+            function.typeParameters,
+            strongModeOnly: true))..parent = procedure;
     handleNativeBody(function.body);
   }
 
   visitNode(AstNode node) {
     log.severe('Unexpected class or library member: $node');
   }
 }
 
 /// Internal exception thrown from the expression or statement builder when a
 /// compilation error is found.
@@ skipping 103 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }