Mix in [TreeElementMixin] only on nodes that need it.

sdk/lib/_internal/compiler/implementation/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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
   /// Iterables of the dependencies that this [TreeElement] records of
   /// [currentElement].
   Iterable<Element> get allElements;
   void forEachConstantNode(f(Node n, Constant c));
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Setlet<Element> get otherDependencies;
 
   Element operator[](Node node);
-  Selector getSelector(Send send);
+
+  // TODO(johnniwinther): Investigate whether [Node] could be a [Send].
+  Selector getSelector(Node node);
   Selector getGetterSelectorInComplexSendSet(SendSet node);
   Selector getOperatorSelectorInComplexSendSet(SendSet node);
   DartType getType(Node node);
   void setSelector(Node node, Selector selector);
   void setGetterSelectorInComplexSendSet(SendSet node, Selector selector);
   void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector);
+
+  /// Returns the for-in loop variable for [node].
+  Element getForInVariable(ForIn node);
   Selector getIteratorSelector(ForIn node);
   Selector getMoveNextSelector(ForIn node);
   Selector getCurrentSelector(ForIn node);
   void setIteratorSelector(ForIn node, Selector selector);
   void setMoveNextSelector(ForIn node, Selector selector);
   void setCurrentSelector(ForIn node, Selector selector);
   void setConstant(Node node, Constant constant);
   Constant getConstant(Node node);
   bool isAssert(Send send);
 
+  /// Returns the [FunctionElement] defined by [node].
+  FunctionElement getFunctionDefinition(FunctionExpression node);
+
+  /// Returns target constructor for the redirecting factory body [node].
+  ConstructorElement getRedirectingTargetConstructor(
+      RedirectingFactoryBody node);
+
   /**
    * Returns [:true:] if [node] is a type literal.
    *
    * Resolution marks this by setting the type on the node to be the
    * type that the literal refers to.
    */
   bool isTypeLiteral(Send node);
 
   /// Returns the type that the type literal [node] refers to.
   DartType getTypeLiteralType(Send node);
@@ skipping 142 matching lines @@
   }
 
   void setCurrentSelector(ForIn node, Selector selector) {
     selectors[node.inToken] = selector;
   }
 
   Selector getCurrentSelector(ForIn node) {
     return selectors[node.inToken];
   }
 
+  Element getForInVariable(ForIn node) {
+    return this[node];
+  }
+
   void setConstant(Node node, Constant constant) {
     constants[node] = constant;
   }
 
   Constant getConstant(Node node) {
     return constants[node];
   }
 
   bool isTypeLiteral(Send node) {
     return getType(node) != null;
@@ skipping 69 matching lines @@
   void forEachConstantNode(f(Node n, Constant c)) => constants.forEach(f);
 
   void setAssert(Send node) {
     asserts.add(node);
   }
 
   bool isAssert(Send node) {
     return asserts.contains(node);
   }
 
+  FunctionElement getFunctionDefinition(FunctionExpression node) {
+    return this[node];
+  }
+
+  ConstructorElement getRedirectingTargetConstructor(
+      RedirectingFactoryBody node) {
+    return this[node];
+  }
+
   void defineTarget(Node node, JumpTarget target) {
     if (definedTargets == null) {
       // TODO(johnniwinther): Use [Maplet] when available.
       definedTargets = <Node, JumpTarget>{};
     }
     definedTargets[node] = target;
   }
 
   void undefineTarget(Node node) {
     if (definedTargets != null) {
@@ skipping 293 matching lines @@
           }
           if (element.modifiers.isConst &&
               tree.hasBody() &&
               !tree.isRedirectingFactory) {
             compiler.reportError(tree, MessageKind.CONST_CONSTRUCTOR_HAS_BODY);
           }
         }
 
         ResolverVisitor visitor = visitorFor(element);
         ResolutionRegistry registry = visitor.registry;
-        registry.useElement(tree, element);
+        registry.defineFunction(tree, element);
         visitor.setupFunction(tree, element);
 
         if (isConstructor && !element.isForwardingConstructor) {
           // Even if there is no initializer list we still have to do the
           // resolution in case there is an implicit super constructor call.
           InitializerResolver resolver = new InitializerResolver(visitor);
           FunctionElement redirection =
               resolver.resolveInitializers(element, tree);
           if (redirection != null) {
             resolveRedirectingConstructor(resolver, tree, element, redirection);
@@ skipping 38 matching lines @@
   /// does not include inner scope of [element].
   ///
   /// This method should only be used by this library (or tests of
   /// this library).
   ResolverVisitor visitorFor(Element element, {bool useEnclosingScope: false}) {
     return new ResolverVisitor(compiler, element,
         new ResolutionRegistry(compiler, element),
         useEnclosingScope: useEnclosingScope);
   }
 
-  TreeElements resolveField(VariableElementX element) {
+  TreeElements resolveField(FieldElementX element) {
     VariableDefinitions tree = element.parseNode(compiler);
     if(element.modifiers.isStatic && element.isTopLevel) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     ResolutionRegistry registry = visitor.registry;
     // TODO(johnniwinther): Share the resolved type between all variables
     // declared in the same declaration.
     if (tree.type != null) {
       element.variables.type = visitor.resolveTypeAnnotation(tree.type);
     } else {
       element.variables.type = const DynamicType();
     }
-    registry.useElement(tree, element);
 
     Expression initializer = element.initializer;
     Modifiers modifiers = element.modifiers;
     if (initializer != null) {
       // TODO(johnniwinther): Avoid analyzing initializers if
       // [Compiler.analyzeSignaturesOnly] is set.
       visitor.visit(initializer);
     } else if (modifiers.isConst) {
       compiler.reportError(element, MessageKind.CONST_WITHOUT_INITIALIZER);
     } else if (modifiers.isFinal && !element.isInstanceMember) {
@@ skipping 83 matching lines @@
       ConstructorElementX factory = seen.removeLast();
 
       // [factory] must already be analyzed but the [TreeElements] might not
       // have been stored in the enqueuer cache yet.
       // TODO(johnniwinther): Store [TreeElements] in the cache before
       // resolution of the element.
       TreeElements treeElements = factory.treeElements;
       assert(invariant(node, treeElements != null,
           message: 'No TreeElements cached for $factory.'));
       FunctionExpression functionNode = factory.parseNode(compiler);
-      Return redirectionNode = functionNode.body;
-      InterfaceType factoryType =
-          treeElements.getType(redirectionNode.expression);
+      RedirectingFactoryBody redirectionNode = functionNode.body;
+      InterfaceType factoryType = treeElements.getType(redirectionNode);
 
       targetType = targetType.substByContext(factoryType);
       factory.effectiveTarget = target;
       factory.effectiveTargetType = targetType;
     }
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
@@ skipping 1219 matching lines @@
   final TypeResolver typeResolver;
   /// The current enclosing element for the visited AST nodes.
   Element get enclosingElement;
   /// The current scope of the visitor.
   Scope get scope;
 
   MappingVisitor(Compiler compiler, ResolutionRegistry this.registry)
       : typeResolver = new TypeResolver(compiler),
         super(compiler);
 
-  Element defineElement(Node node, Element element,
-                        {bool doAddToScope: true}) {
+  /// Add [element] to the current scope and check for duplicate definitions.
+  void addToScope(Element element) {
+    Element existing = scope.add(element);
+    if (existing != element) {
+      reportDuplicateDefinition(element.name, element, existing);
+    }
+  }
+
+  /// Register [node] as the definition of [element].
+  void defineLocalVariable(Node node, LocalVariableElement element) {
     invariant(node, element != null);
     registry.defineElement(node, element);
-    if (doAddToScope) {
-      Element existing = scope.add(element);
-      if (existing != element) {
-        reportDuplicateDefinition(node, element, existing);
-      }
-    }
-    return element;
   }
 
-  void reportDuplicateDefinition(/*Node|String*/ name,
+  void reportDuplicateDefinition(String name,
                                  Spannable definition,
                                  Spannable existing) {
     compiler.reportError(definition,
         MessageKind.DUPLICATE_DEFINITION, {'name': name});
     compiler.reportInfo(existing,
         MessageKind.EXISTING_DEFINITION, {'name': name});
   }
 }
 
 /**
  * Core implementation of resolution.
  *
  * Do not subclass or instantiate this class outside this library
  * except for testing.
  */
 class ResolverVisitor extends MappingVisitor<ResolutionResult> {
   /**
    * The current enclosing element for the visited AST nodes.
    *
    * This field is updated when nested closures are visited.
    */
   Element enclosingElement;
   bool inInstanceContext;
   bool inCheckContext;
   bool inCatchBlock;
+
+  /// Is `true` when the current node is the immediate child of a function
+  /// declaration.
+  ///
+  /// This is used to distinguish local function declarations from anonymous
+  /// function expressions.
+  bool inFunctionDeclaration = false;
+
   Scope scope;
   ClassElement currentClass;
   ExpressionStatement currentExpressionStatement;
   bool sendIsMemberAccess = false;
   StatementScope statementScope;
   int allowedCategory = ElementCategory.VARIABLE | ElementCategory.FUNCTION
       | ElementCategory.IMPLIES_TYPE;
 
   /**
    * Record of argument nodes to JS_INTERCEPTOR_CONSTANT for deferred
@@ skipping 237 matching lines @@
         parameterNodes = nodes.nodes;
       }
       visit(element.initializer);
       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 {
-        defineElement(parameterNode, element);
+        LocalParameterElement parameterElement = element;
+        defineLocalVariable(parameterNode, parameterElement);
+        addToScope(parameterElement);
       }
       parameterNodes = parameterNodes.tail;
     });
     addDeferredAction(enclosingElement, () {
       functionParameters.forEachOptionalParameter((Element parameter) {
         compiler.resolver.constantCompiler.compileConstant(parameter);
       });
     });
     if (inCheckContext) {
       functionParameters.forEachParameter((ParameterElement element) {
@@ skipping 56 matching lines @@
 
   visitFor(For node) {
     Scope blockScope = new BlockScope(scope);
     visitIn(node.initializer, blockScope);
     visitIn(node.condition, blockScope);
     visitIn(node.update, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
+    inFunctionDeclaration = true;

[floitsch, 2014/07/25 12:30:08]

Add comment explaining that the boolean is reset inside the
visitFunctionExpression.

Alternatively call visitFunctionExpression directly (instead of through "visit")
and pass in an optional boolean argument. I think I would prefer that.

[Johnni Winther, 2014/08/04 06:59:09]

Done.

     assert(node.function.name != null);
     visit(node.function);
-    FunctionElement functionElement = registry.getDefinition(node.function);
-    // TODO(floitsch): this might lead to two errors complaining about
-    // shadowing.
-    defineElement(node, functionElement);
   }
 
   visitFunctionExpression(FunctionExpression node) {
+    bool doAddToScope = inFunctionDeclaration;
+    if (!inFunctionDeclaration && node.name != null) {
+      compiler.reportError(
+          node.name,
+          MessageKind.NAMED_FUNCTION_EXPRESSION,
+          {'name': node.name});
+    }
+    inFunctionDeclaration = false;
     visit(node.returnType);
     String name;
     if (node.name == null) {
       name = "";
     } else {
       name = node.name.asIdentifier().source;
     }
     LocalFunctionElementX function = new LocalFunctionElementX(
         name, node, ElementKind.FUNCTION, Modifiers.EMPTY,
         enclosingElement);
     function.functionSignatureCache =
         SignatureResolver.analyze(compiler, node.parameters, node.returnType,
             function, registry, createRealParameters: true);
+    registry.defineFunction(node, function);
+    if (doAddToScope) {
+      addToScope(function);
+    }
     Scope oldScope = scope; // The scope is modified by [setupFunction].
     setupFunction(node, function);
-    defineElement(node, function, doAddToScope: node.name != null);
 
     Element previousEnclosingElement = enclosingElement;
     enclosingElement = function;
     // Run the body in a fresh statement scope.
     StatementScope oldStatementScope = statementScope;
     statementScope = new StatementScope();
     visit(node.body);
     statementScope = oldStatementScope;
 
     scope = oldScope;
@@ skipping 577 matching lines @@
     internalError(node, 'operator');
   }
 
   visitRethrow(Rethrow node) {
     if (!inCatchBlock) {
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
   }
 
   visitReturn(Return node) {
-    if (node.isRedirectingFactoryBody) {
-      handleRedirectingFactoryBody(node);
-    } else {
-      Node expression = node.expression;
-      if (expression != null &&
-          enclosingElement.isGenerativeConstructor) {
-        // It is a compile-time error if a return statement of the form
-        // `return e;` appears in a generative constructor.  (Dart Language
-        // Specification 13.12.)
-        compiler.reportError(expression,
-                             MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
-      }
-      visit(node.expression);
+    Node expression = node.expression;
+    if (expression != null &&
+        enclosingElement.isGenerativeConstructor) {
+      // It is a compile-time error if a return statement of the form
+      // `return e;` appears in a generative constructor.  (Dart Language
+      // Specification 13.12.)
+      compiler.reportError(expression,
+                           MessageKind.CANNOT_RETURN_FROM_CONSTRUCTOR);
     }
+    visit(node.expression);
   }
 
-  void handleRedirectingFactoryBody(Return node) {
+  visitRedirectingFactoryBody(RedirectingFactoryBody node) {
     final isSymbolConstructor = enclosingElement == compiler.symbolConstructor;
     if (!enclosingElement.isFactoryConstructor) {
       compiler.reportError(
           node, MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY);
       compiler.reportHint(
           enclosingElement, MessageKind.MISSING_FACTORY_KEYWORD);
     }
     ConstructorElementX constructor = enclosingElement;
     bool isConstConstructor = constructor.isConst;
     ConstructorElement redirectionTarget = resolveRedirectingFactory(
         node, inConstContext: isConstConstructor);
     constructor.immediateRedirectionTarget = redirectionTarget;
-    registry.useElement(node.expression, redirectionTarget);
+    registry.setRedirectingTargetConstructor(node, redirectionTarget);
     if (Elements.isUnresolved(redirectionTarget)) {
       registry.registerThrowNoSuchMethod();
       return;
     } else {
       if (isConstConstructor &&
           !redirectionTarget.isConst) {
         compiler.reportError(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
       }
       if (redirectionTarget == constructor) {
         compiler.reportError(node, MessageKind.CYCLIC_REDIRECTING_FACTORY);
         return;
       }
     }
 
     // Check that the target constructor is type compatible with the
     // redirecting constructor.
     ClassElement targetClass = redirectionTarget.enclosingClass;
-    InterfaceType type = registry.getType(node.expression);
+    InterfaceType type = registry.getType(node);
     FunctionType targetType = redirectionTarget.computeType(compiler)
         .subst(type.typeArguments, targetClass.typeVariables);
     FunctionType constructorType = constructor.computeType(compiler);
     bool isSubtype = compiler.types.isSubtype(targetType, constructorType);
     if (!isSubtype) {
       warning(node, MessageKind.NOT_ASSIGNABLE,
               {'fromType': targetType, 'toType': constructorType});
     }
 
     FunctionSignature targetSignature =
@@ skipping 220 matching lines @@
 
   /**
    * Try to resolve the constructor that is referred to by [node].
    * Note: this function may return an ErroneousFunctionElement instead of
    * [:null:], if there is no corresponding constructor, class or library.
    */
   ConstructorElement resolveConstructor(NewExpression node) {
     return node.accept(new ConstructorResolver(compiler, this));
   }
 
-  ConstructorElement resolveRedirectingFactory(Return node,
+  ConstructorElement resolveRedirectingFactory(RedirectingFactoryBody node,
                                                {bool inConstContext: false}) {
     return node.accept(new ConstructorResolver(compiler, this,
                                                inConstContext: inConstContext));
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node,
                                  {bool malformedIsError: false,
                                   bool deferredIsMalformed: true}) {
     DartType type = typeResolver.resolveTypeAnnotation(
         this, node, malformedIsError: malformedIsError,
@@ skipping 177 matching lines @@
     }
     if (loopVariableSelector != null) {
       registry.setSelector(declaration, loopVariableSelector);
       registerSend(loopVariableSelector, loopVariable);
     } else {
       // The selector may only be null if we reported an error.
       assert(invariant(declaration, compiler.compilationFailed));
     }
     if (loopVariable != null) {
       // loopVariable may be null if it could not be resolved.
-      registry.defineElement(declaration, loopVariable);
+      registry.setForInVariable(node, loopVariable);
     }
     visitLoopBodyIn(node, node.body, blockScope);
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Statement body = node.statement;
@@ skipping 415 matching lines @@
     TypedefType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     FunctionSignature signature = SignatureResolver.analyze(
         compiler, node.formals, node.returnType, element, registry,
         defaultValuesError: MessageKind.TYPEDEF_FORMAL_WITH_DEFAULT);
     element.functionSignature = signature;
 
     scope = new MethodScope(scope, element);
-    signature.forEachParameter((FormalElement element) {
-      defineElement(element.node, element);
-    });
+    signature.forEachParameter(addToScope);
 
     element.alias = signature.type;
 
     void checkCyclicReference() {
       element.checkCyclicReference(compiler);
     }
     addDeferredAction(element, checkCyclicReference);
   }
 }
 
@@ skipping 626 matching lines @@
     if (definitions.modifiers.isFinal &&
         !resolver.allowFinalWithoutInitializer) {
       compiler.reportError(node, MessageKind.FINAL_WITHOUT_INITIALIZER);
     }
     return node;
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       Identifier name = visit(link.head);
-      VariableElement element = new LocalVariableElementX(
+      LocalVariableElement element = new LocalVariableElementX(
           name.source, resolver.enclosingElement,
           variables, name.token);
-      resolver.defineElement(link.head, element);
+      resolver.defineLocalVariable(link.head, element);
+      resolver.addToScope(element);
       if (definitions.modifiers.isConst) {
         compiler.enqueuer.resolution.addDeferredAction(element, () {
           compiler.resolver.constantCompiler.compileConstant(element);
         });
       }
     }
   }
 }
 
 class ConstructorResolver extends CommonResolverVisitor<Element> {
@@ skipping 159 matching lines @@
     } else if (element.isTypeVariable) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
             {'typeVariableName': name});
     } else if (!element.isClass && !element.isPrefix) {
       error(node, MessageKind.NOT_A_TYPE, {'node': name});
     }
     return element;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
-  Element visitReturn(Return node) {
-    Node expression = node.expression;
-    return finishConstructorReference(visit(expression),
-                                      expression, expression);
+  Element visitRedirectingFactoryBody(RedirectingFactoryBody node) {
+    Node constructorReference = node.constructorReference;
+    return finishConstructorReference(visit(constructorReference),
+        constructorReference, node);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }
 
 TreeElements _ensureTreeElements(AnalyzableElementX element) {
@@ skipping 49 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }