Implements support for ignoring method type arguments in resolution.

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

 // Copyright (c) 2012, 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 dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Feature;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart'
     show RedirectingFactoryConstantConstructor;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
+        BaseFunctionElementX,
         ConstructorElementX,
         ErroneousElementX,
         FunctionElementX,
         JumpTargetX,
         LocalFunctionElementX,
         LocalParameterElementX,
         MethodElementX,
         ParameterElementX,
         VariableElementX,
         VariableList;
@@ skipping 106 matching lines @@
           r'>|'
           r'<=|'
           r'<|'
           r'&|'
           r'\^|'
           r'\|'
           r')$');
 
   ResolverVisitor(
       Compiler compiler, Element element, ResolutionRegistry registry,
-      {bool useEnclosingScope: false})
+      {Scope scope, bool useEnclosingScope: false})
       : this.enclosingElement = element,
         // When the element is a field, we are actually resolving its
         // initial value, which should not have access to instance
         // fields.
         inInstanceContext = (element.isInstanceMember && !element.isField) ||
             element.isGenerativeConstructor,
         this.currentClass =
             element.isClassMember ? element.enclosingClass : null,
         this.statementScope = new StatementScope(),
-        scope = useEnclosingScope
+        this.scope = scope ?? (useEnclosingScope
             ? Scope.buildEnclosingScope(element)
-            : element.buildScope(),
+            : element.buildScope()),
         // The type annotations on a typedef do not imply type checks.
         // TODO(karlklose): clean this up (dartbug.com/8870).
         inCheckContext = compiler.options.enableTypeAssertions &&
             !element.isLibrary &&
             !element.isTypedef &&
             !element.enclosingElement.isTypedef,
         inCatchBlock = false,
         constantState = element.isConst
             ? ConstantState.CONSTANT
             : ConstantState.NON_CONSTANT,
@@ skipping 232 matching lines @@
       return classElement.lookupConstructor(name.text);
     }
     return null;
   }
 
   void setupFunction(FunctionExpression node, FunctionElement function) {
     Element enclosingElement = function.enclosingElement;
     if (node.modifiers.isStatic && enclosingElement.kind != ElementKind.CLASS) {
       reporter.reportErrorMessage(node, MessageKind.ILLEGAL_STATIC);
     }
+    FunctionSignature functionSignature = function.functionSignature;
 
+    // Create the scope where the type variables are introduced, if any.
     scope = new MethodScope(scope, function);
-    // Put the parameters in scope.
-    FunctionSignature functionParameters = function.functionSignature;
+    functionSignature.typeVariables.forEach(
+        (DartType type) => addToScope(type.element));
+
+    // Create the scope for the function body, and put the parameters in scope.
+    scope = new BlockScope(scope);
     Link<Node> parameterNodes =
         (node.parameters == null) ? const Link<Node>() : node.parameters.nodes;
-    functionParameters.forEachParameter((ParameterElementX element) {
+    functionSignature.forEachParameter((ParameterElementX element) {
       // TODO(karlklose): should be a list of [FormalElement]s, but the actual
       // implementation uses [Element].
-      List<Element> optionals = functionParameters.optionalParameters;
+      List<Element> optionals = functionSignature.optionalParameters;
       if (!optionals.isEmpty && element == optionals.first) {
         NodeList nodes = parameterNodes.head;
         parameterNodes = nodes.nodes;
       }
       if (element.isOptional) {
         if (element.initializer != null) {
           ResolutionResult result = visitInConstantContext(element.initializer);
           if (result.isConstant) {
             element.constant = result.constant;
           }
         } else {
           element.constant = new NullConstantExpression();
         }
       }
       VariableDefinitions variableDefinitions = parameterNodes.head;
       Node parameterNode = variableDefinitions.definitions.nodes.head;
       // Field parameters (this.x) are not visible inside the constructor. The
       // fields they reference are visible, but must be resolved independently.
       if (element.isInitializingFormal) {
         registry.useElement(parameterNode, element);
       } else {
         LocalParameterElementX parameterElement = element;
         defineLocalVariable(parameterNode, parameterElement);
         addToScope(parameterElement);
       }
       parameterNodes = parameterNodes.tail;
     });
     addDeferredAction(enclosingElement, () {
-      functionParameters
+      functionSignature
           .forEachOptionalParameter((ParameterElementX parameter) {
         parameter.constant =
             compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
-      functionParameters.forEachParameter((ParameterElement element) {
+      functionSignature.forEachParameter((ParameterElement element) {
         registry.registerTypeUse(new TypeUse.checkedModeCheck(element.type));
       });
     }
   }
 
   ResolutionResult visitAssert(Assert node) {
     if (!compiler.options.enableAssertMessage) {
       if (node.hasMessage) {
         reporter.reportErrorMessage(
             node, MessageKind.EXPERIMENTAL_ASSERT_MESSAGE);
@@ skipping 96 matching lines @@
     String name;
     if (node.name == null) {
       name = "";
     } else {
       name = node.name.asIdentifier().source;
     }
     LocalFunctionElementX function = new LocalFunctionElementX(
         name, node, ElementKind.FUNCTION, Modifiers.EMPTY, enclosingElement);
     ResolverTask.processAsyncMarker(compiler, function, registry);
     function.functionSignature = SignatureResolver.analyze(
-        compiler, node.parameters, node.returnType, function, registry,
+        compiler,
+        scope,
+        node.typeVariables,
+        node.parameters,
+        node.returnType,
+        function,
+        registry,
         createRealParameters: true,
         isFunctionExpression: !inFunctionDeclaration);
     checkLocalDefinitionName(node, function);
     registry.defineFunction(node, function);
     if (doAddToScope) {
       addToScope(function);
     }
     Scope oldScope = scope; // The scope is modified by [setupFunction].
     setupFunction(node, function);
 
@@ skipping 1273 matching lines @@
 
   /// Handle access to a type literal of type variable [element]. Like `T` or
   /// `T()` where 'T' is type variable.
   // TODO(johnniwinther): Remove [name] when [Selector] is not required for the
   // the [GetStructure].
   // TODO(johnniwinther): Remove [element] when it is no longer needed for
   // evaluating constants.
   ResolutionResult handleTypeVariableTypeLiteralAccess(
       Send node, Name name, TypeVariableElement element) {
     AccessSemantics semantics;
-    if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
+    if (!Elements.hasAccessToTypeVariables(enclosingElement) &&

[Johnni Winther, 2016/04/29 07:21:06]

Move the check of `element.typeDeclaration is TypeDeclarationElement` into
`hasAccessTypeVariables` (probably by changing it to `hasAccessTypeVariable` and
giving it the [TypeVariableElement] instead)

[eernst, 2016/04/29 13:24:50]

Done.

+        element.typeDeclaration is TypeDeclarationElement) {
       // TODO(johnniwinther): Add another access semantics for this.
       ErroneousElement error = reportAndCreateErroneousElement(
           node,
           name.text,
           MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
           {'typeVariableName': name},
           isError: true);
       registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       semantics = new StaticAccess.invalid(error);
       // TODO(johnniwinther): Clean up registration of elements and selectors
@@ skipping 20 matching lines @@
       registry.registerSendStructure(node, new GetStructure(semantics));
     }
     return const NoneResult();
   }
 
   /// Handle access to a type literal of type variable [element]. Like `T = b`,
   /// `T++` or `T += b` where 'T' is type variable.
   ResolutionResult handleTypeVariableTypeLiteralUpdate(
       SendSet node, Name name, TypeVariableElement element) {
     AccessSemantics semantics;
-    if (!Elements.hasAccessToTypeVariables(enclosingElement)) {
+    if (!Elements.hasAccessToTypeVariables(enclosingElement) &&
+        element.typeDeclaration is TypeDeclarationElement) {
       // TODO(johnniwinther): Add another access semantics for this.
       ErroneousElement error = reportAndCreateErroneousElement(
           node,
           name.text,
           MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
           {'typeVariableName': name},
           isError: true);
       registry.registerFeature(Feature.COMPILE_TIME_ERROR);
       semantics = new StaticAccess.invalid(error);
     } else {
@@ skipping 2752 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }