Implement type variables on local function declarations and expressions.

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 'package:kernel/ast.dart'
     hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
@@ skipping 299 matching lines @@
         if (outerSwitchScope == null) {
           deprecated_addCompileTimeError(-1, "Label not found: '$name'.");
         } else {
           outerSwitchScope.forwardDeclareLabel(name, builder);
         }
       });
     }
     switchScope = outerSwitchScope;
   }
 
-  void declareVariable(VariableDeclaration variable) {
+  void declareVariable(VariableDeclaration variable, Scope scope) {
     // ignore: UNUSED_LOCAL_VARIABLE
     Statement discardedStatement;
     String name = variable.name;
     int offset = variable.fileOffset;
     if (scope.local[name] != null) {
       // This reports an error for duplicated declarations in the same scope:
       // `{ var x; var x; }`
       discardedStatement = pop(); // TODO(ahe): Issue 29717.
       push(deprecated_buildCompileTimeErrorStatement(
           "'$name' already declared in this scope.", offset));
@@ skipping 723 matching lines @@
     }
     push(new Identifier(token));
   }
 
   /// Look up [name] in [scope] using [token] as location information (both to
   /// report problems and as the file offset in the generated kernel code).
   /// [isQualified] should be true if [name] is a qualified access
   /// (which implies that it shouldn't be turned into a [ThisPropertyAccessor]
   /// if the name doesn't resolve in the scope).
   @override
   scopeLookup(Scope scope, String name, Token token,

[danrubel, 2017/08/14 14:08:04]

It is confusing to have a field and a parameter both named "scope"

[ahe, 2017/08/15 08:59:28]

Yeah. I'll address this in a follow-up.

       {bool isQualified: false, PrefixBuilder prefix}) {
     Builder builder = scope.lookup(name, offsetForToken(token), uri);
     if (builder != null && member.isField && builder.isInstanceMember) {
       return new IncompleteError(this, token,
           fasta.templateThisAccessInFieldInitializer.withArguments(name));
     }
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
       if (prefix != null &&
           prefix.deferred &&
@@ skipping 312 matching lines @@
     }
   }
 
   @override
   void endInitializedIdentifier(Token nameToken) {
     // TODO(ahe): Use [InitializedIdentifier] here?
     debugEvent("InitializedIdentifier");
     VariableDeclaration variable = pop();
     variable.fileOffset = nameToken.charOffset;
     push(variable);
-    declareVariable(variable);
+    declareVariable(variable, scope);
   }
 
   @override
   void beginVariablesDeclaration(Token token) {
     debugEvent("beginVariablesDeclaration");
     DartType type = pop();
     int modifiers = Modifier.validate(pop());
     super.push(currentLocalVariableModifiers);
     super.push(currentLocalVariableType ?? NullValue.Type);
     currentLocalVariableType = type;
@@ skipping 1002 matching lines @@
       ..fileOffset = offsetForToken(name.token);
     if (scope.local[variable.name] != null) {
       deprecated_addCompileTimeError(offsetForToken(name.token),
           "'${variable.name}' already declared in this scope.");
     }
     push(new KernelFunctionDeclaration(
         variable,
         // The function node is created later.
         null)
       ..fileOffset = beginToken.charOffset);
-    declareVariable(variable);
-    enterLocalScope();
+    declareVariable(variable, scope.parent);
   }
 
   void enterFunction() {
     debugEvent("enterFunction");
+    enterFunctionTypeScope();
     functionNestingLevel++;
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = null;
     push(inCatchBlock);
     inCatchBlock = false;
   }
 
   void exitFunction() {
     debugEvent("exitFunction");
     functionNestingLevel--;
     inCatchBlock = pop();
     switchScope = pop();
+    List typeVariables = pop();
+    exitLocalScope();
+    push(typeVariables ?? NullValue.TypeVariables);
   }
 
   @override
   void beginLocalFunctionDeclaration(Token token) {
     debugEvent("beginLocalFunctionDeclaration");
     enterFunction();
   }
 
   @override
   void beginNamedFunctionExpression(Token token) {
     debugEvent("beginNamedFunctionExpression");
+    List typeVariables = pop();
+    // Create an additional scope in which the named function expression is
+    // declared.
+    enterLocalScope();
+    push(typeVariables ?? NullValue.TypeVariables);
     enterFunction();
   }
 
   @override
   void beginFunctionExpression(Token token) {
     debugEvent("beginFunctionExpression");
     enterFunction();
   }
 
-  @override
-  void endNamedFunctionExpression(Token endToken) {
-    debugEvent("NamedFunctionExpression");
+  void pushNamedFunction(Token token, bool isFunctionExpression) {
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
-    if (functionNestingLevel != 0) {
-      exitLocalScope();
-    }
+    exitLocalScope();
     FormalParameters formals = pop();
-    List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
-
-    exitLocalScope();
-    KernelFunctionDeclaration declaration = pop();
-    VariableDeclaration variable = declaration.variable;
-    var returnType = pop();
-    returnType ??= const DynamicType();
-    pop(); // Modifiers.
-    exitFunction();
-
-    variable.initializer = new KernelFunctionExpression(formals.addToFunction(
-        new FunctionNode(body,
-            typeParameters: typeParameters, asyncMarker: asyncModifier)
-          ..fileOffset = formals.charOffset
-          ..fileEndOffset = endToken.charOffset))
-      ..parent = variable
-      ..fileOffset = formals.charOffset;
-    push(
-        new KernelNamedFunctionExpression(variable, new VariableGet(variable)));
-  }
-
-  @override
-  void endLocalFunctionDeclaration(Token token) {
-    debugEvent("LocalFunctionDeclaration");
-    Statement body = popStatement();
-    AsyncMarker asyncModifier = pop();
-    if (functionNestingLevel != 0) {
-      exitLocalScope();
-    }
-    FormalParameters formals = pop();
-    exitLocalScope();
     var declaration = pop();
     var returnType = pop();
     var hasImplicitReturnType = returnType == null;
     returnType ??= const DynamicType();
     pop(); // Modifiers.
     exitFunction();
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
-        typeParameters: typeParameters, asyncMarker: asyncModifier)
+        typeParameters: typeParameters,
+        asyncMarker: asyncModifier,
+        returnType: returnType)
       ..fileOffset = formals.charOffset
       ..fileEndOffset = token.charOffset);
+
     if (declaration is FunctionDeclaration) {
+      VariableDeclaration variable = declaration.variable;
       KernelFunctionDeclaration.setHasImplicitReturnType(
           declaration, hasImplicitReturnType);
-      function.returnType = returnType;
-      declaration.variable.type = function.functionType;
-      declaration.function = function;
-      function.parent = declaration;
-    } else {
+
+      variable.type = function.functionType;
+      if (isFunctionExpression) {
+        variable.initializer = new KernelFunctionExpression(function)
+          ..parent = variable
+          ..fileOffset = formals.charOffset;
+        exitLocalScope();
+        push(new KernelNamedFunctionExpression(variable));
+      } else {
+        declaration.function = function;
+        function.parent = declaration;
+        push(declaration);
+      }
+    } else if (declaration is ExpressionStatement) {
       // If [declaration] isn't a [FunctionDeclaration], it must be because
       // there was a compile-time error.
+      assert(library.hasCompileTimeErrors);
 
-      // TODO(paulberry): ensure that when integrating with analyzer, type
+      // TODO(paulberry,ahe): ensure that when integrating with analyzer, type
       // inference is still performed for the dropped declaration.
-      assert(library.hasCompileTimeErrors);
+      if (isFunctionExpression) {
+        push(declaration.expression);
+      } else {
+        push(declaration);
+      }
+    } else {
+      return unhandled("${declaration.runtimeType}", "pushNamedFunction",
+          token.charOffset, uri);
     }
-    push(declaration);
   }
 
   @override
+  void endNamedFunctionExpression(Token endToken) {
+    debugEvent("NamedFunctionExpression");
+    pushNamedFunction(endToken, true);
+  }
+
+  @override
+  void endLocalFunctionDeclaration(Token token) {
+    debugEvent("LocalFunctionDeclaration");
+    pushNamedFunction(token, false);
+  }
+
+  @override
   void endFunctionExpression(Token beginToken, Token token) {
     debugEvent("FunctionExpression");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
     FormalParameters formals = pop();
     exitFunction();
     List<TypeParameter> typeParameters = typeVariableBuildersToKernel(pop());
     FunctionNode function = formals.addToFunction(new FunctionNode(body,
         typeParameters: typeParameters, asyncMarker: asyncModifier)
@@ skipping 1269 matching lines @@
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return unhandled(asyncToken.lexeme, "asyncMarkerFromTokens",
         asyncToken.charOffset, null);
   }
 }