Implement type variables on generalized function types.

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import '../fasta_codes.dart'
     show
         FastaMessage,
         codeConstFieldWithoutInitializer,
@@ skipping 1680 matching lines @@
     } else if (name is Builder) {
       push(kernelTypeFromBuilder(name, arguments, beginToken.charOffset));
     } else if (name is String) {
       push(kernelTypeFromString(name, arguments, beginToken.charOffset));
     } else {
       internalError("Unhandled: '${name.runtimeType}'.");
     }
   }
 
   @override
+  void beginFunctionType(Token beginToken) {
+    debugEvent("beginFunctionType");
+    List typeVariables = pop();
+    enterLocalScope(scope.createNestedScope(isModifiable: false));
+    push(typeVariables ?? NullValue.TypeVariables);
+    if (typeVariables != null) {
+      ScopeBuilder scopeBuilder = new ScopeBuilder(scope);
+      for (KernelTypeVariableBuilder builder in typeVariables) {
+        String name = builder.name;
+        KernelTypeVariableBuilder existing = scopeBuilder[name];
+        if (existing == null) {
+          scopeBuilder.addMember(name, builder);
+        } else {
+          addCompileTimeError(
+              builder.charOffset, "'$name' already declared in this scope.");
+          addCompileTimeError(
+              existing.charOffset, "Previous definition of '$name'.");
+        }
+      }
+    }
+  }
+
+  @override
   void endFunctionType(Token functionToken, Token endToken) {
     debugEvent("FunctionType");
     FormalParameters formals = pop();
     DartType returnType = pop();
-    ignore(Unhandled.TypeVariables);
-    push(formals.toFunctionType(returnType));
+    List<TypeParameter> typeVariables = typeVariableBuildersToKernel(pop());
+    FunctionType type = formals.toFunctionType(returnType, typeVariables);
+    exitLocalScope();
+    push(type);
   }
 
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(const VoidType());
   }
 
   @override
   void handleAsOperator(Token operator, Token endToken) {
@@ skipping 679 matching lines @@
 
   @override
   void endFunction(Token getOrSet, Token endToken) {
     debugEvent("Function");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     if (functionNestingLevel != 0) {
       exitLocalScope();
     }
     FormalParameters formals = pop();
-    List<TypeParameter> typeParameters = pop();
+    List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     push(formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = formals.charOffset
       ..fileEndOffset = endToken.charOffset));
   }
 
   @override
   void endFunctionDeclaration(Token token) {
     debugEvent("FunctionDeclaration");
     FunctionNode function = pop();
@@ skipping 23 matching lines @@
   }
 
   @override
   void endUnnamedFunction(Token beginToken, Token token) {
     debugEvent("UnnamedFunction");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
-    List<TypeParameter> typeParameters = pop();
+    List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
       ..fileOffset = beginToken.charOffset
       ..fileEndOffset = token.charOffset);
     if (constantExpressionRequired) {
       push(buildCompileTimeError(
           "Not a constant expression.", formals.charOffset));
     } else {
       push(new KernelFunctionExpression(function)
         ..fileOffset = offsetForToken(beginToken));
@@ skipping 447 matching lines @@
       BreakStatement statement = new KernelBreakStatement(null)
         ..fileOffset = continueKeyword.charOffset;
       target.addContinue(statement);
       push(statement);
     }
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
     debugEvent("TypeVariable");
-    // TODO(ahe): Do not discard these when enabling generic method syntax.
-    pop(); // Bound.
-    pop(); // Name.
+    DartType bound = pop();
+    if (bound != null) {
+      // TODO(ahe): To handle F-bounded types, this needs to be a TypeBuilder.
+      warningNotError("Type variable bounds not implemented yet.",
+          offsetForToken(extendsOrSuper.next));
+    }
+    Identifier name = pop();
+    // TODO(ahe): Do not discard metadata.
     pop(); // Metadata.
+    push(new KernelTypeVariableBuilder(
+        name.name, library, offsetForToken(name.token), null)
+      ..finish(library, library.loader.coreLibrary["Object"]));
   }
 
   @override
   void endTypeVariables(int count, Token beginToken, Token endToken) {
     debugEvent("TypeVariables");
-    // TODO(ahe): Implement this when enabling generic method syntax.
-    push(NullValue.TypeVariables);
+    push(popList(count) ?? NullValue.TypeVariables);
+  }
+
+  List<TypeParameter> typeVariableBuildersToKernel(List typeVariableBuilders) {
+    if (typeVariableBuilders == null) return null;
+    List<TypeParameter> typeParameters = new List<TypeParameter>.filled(

[Paul Berry, 2017/06/29 17:45:40]

Nit: why not use map()?

[ahe, 2017/07/04 11:07:45]

I try to avoid methods like that because they aren't optimized as well as one
would hope.

+        typeVariableBuilders.length, null,
+        growable: true);
+    int i = 0;
+    for (KernelTypeVariableBuilder builder in typeVariableBuilders) {
+      typeParameters[i++] = builder.target;
+    }
+    return typeParameters;
   }
 
   @override
   void handleModifier(Token token) {
     debugEvent("Modifier");
     // TODO(ahe): Copied from outline_builder.dart.
     push(new Modifier.fromString(token.stringValue));
   }
 
   @override
@@ skipping 625 matching lines @@
         function.positionalParameters.addAll(optional.formals);
       } else {
         function.namedParameters.addAll(optional.formals);
         setParents(function.namedParameters, function);
       }
     }
     setParents(function.positionalParameters, function);
     return function;
   }
 
-  FunctionType toFunctionType(DartType returnType) {
+  FunctionType toFunctionType(DartType returnType,
+      [List<TypeParameter> typeParameters]) {
     returnType ??= const DynamicType();
+    typeParameters ??= const <TypeParameter>[];
     int requiredParameterCount = required.length;
     List<DartType> positionalParameters = <DartType>[];
     List<NamedType> namedParameters = const <NamedType>[];
     for (VariableDeclaration parameter in required) {
       positionalParameters.add(parameter.type);
     }
     if (optional != null) {
       if (optional.kind.isPositional) {
         for (VariableDeclaration parameter in optional.formals) {
           positionalParameters.add(parameter.type);
         }
       } else {
         namedParameters = <NamedType>[];
         for (VariableDeclaration parameter in optional.formals) {
           namedParameters.add(new NamedType(parameter.name, parameter.type));
         }
         namedParameters.sort();
       }
     }
     return new FunctionType(positionalParameters, returnType,
         namedParameters: namedParameters,
-        requiredParameterCount: requiredParameterCount);
+        requiredParameterCount: requiredParameterCount,
+        typeParameters: typeParameters);
   }
 
   Scope computeFormalParameterScope(
       Scope parent, Builder builder, BuilderHelper helper) {
     if (required.length == 0 && optional == null) return parent;
     Map<String, Builder> local = <String, Builder>{};
 
     for (VariableDeclaration parameter in required) {
       if (local[parameter.name] != null) {
         helper.addCompileTimeError(parameter.fileOffset, "Duplicated name.");
@@ skipping 63 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }