Stop resolving all of js_helper unconditionally.

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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 366 matching lines @@
 
   TreeElements resolveField(VariableElement element) {
     Node tree = element.parseNode(compiler);
     if(element.modifiers.isStatic() && element.variables.isTopLevel()) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     initializerDo(tree, visitor.visit);
 
+    if (Elements.isStaticOrTopLevelField(element)) {
+      if (tree.asSendSet() != null) {
+        // TODO(ngeoffray): We could do better here by using the
+        // constant handler to figure out if it's a lazy field or not.
+        compiler.backend.registerLazyField();
+      }
+    }
+
     // Perform various checks as side effect of "computing" the type.
     element.computeType(compiler);
 
     return visitor.mapping;
   }
 
   TreeElements resolveParameter(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor = visitorFor(element.enclosingElement);
     initializerDo(tree, visitor.visit);
@@ skipping 1054 matching lines @@
               new TypedefType(typdef, arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
            type = new TypedefType(typdef, arguments.toLink());
           }
         }
       } else if (element.isTypeVariable()) {
         if (enclosingElement.isInStaticMember()) {
+          compiler.backend.registerThrowRuntimeError();
           compiler.reportWarning(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
                   {'typeVariableName': node}));
           type = new MalformedType(
               new ErroneousElementX(
                   MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
                   {'typeVariableName': node},
                   typeName.source, enclosingElement),
                   element.computeType(compiler));
         } else {
@@ skipping 164 matching lines @@
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(node, node.source,
                                                   MessageKind.CANNOT_RESOLVE,
                                                   {'name': node});
+          compiler.backend.registerThrowNoSuchMethod();
         }
       } else if (element.isErroneous()) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
           error(node, MessageKind.GENERIC,
                 {'text': "is not an expression $element"});
         }
       }
-      if (!Elements.isUnresolved(element)
-          && element.kind == ElementKind.CLASS) {
+      if (!Elements.isUnresolved(element) && element.isClass()) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
+        compiler.backend.registerTypeLiteral();
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (type != null) {
       if (inCheckContext) {
         compiler.enqueuer.resolution.registerIsCheck(type);
@@ skipping 157 matching lines @@
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visit(node.returnType);
     SourceString name;
     if (node.name == null) {
       name = const SourceString("");
     } else {
       name = node.name.asIdentifier().source;
     }
-
     FunctionElement function = new FunctionElementX.node(
         name, node, ElementKind.FUNCTION, Modifiers.EMPTY,
         enclosingElement);
     // [function] and its enclosing method share the same
     // [TreeElementMapping].
     compiler.enqueuer.resolution.resolvedElements[function] = mapping;
     Scope oldScope = scope; // The scope is modified by [setupFunction].
     setupFunction(node, function);
     defineElement(node, function, doAddToScope: node.name != null);
 
@@ skipping 71 matching lines @@
         // This is just to guard against internal errors, so no need
         // for a real error message.
         error(node.receiver, MessageKind.GENERIC,
               {'text': "Object has no superclass"});
       }
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
+      if (target == null) {
+        compiler.backend.registerSuperNoSuchMethod();
+      }
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
-    } else if (identical(resolvedReceiver.kind, ElementKind.CLASS)) {
+    } else if (resolvedReceiver.isClass()) {
       ClassElement receiverClass = resolvedReceiver;
       receiverClass.ensureResolved(compiler);
       if (node.isOperator) {
         // When the resolved receiver is a class, we can have two cases:
         //  1) a static send: C.foo, or
         //  2) an operator send, where the receiver is a class literal: 'C + 1'.
         // The following code that looks up the selector on the resolved
         // receiver will treat the second as the invocation of a static operator
         // if the resolved receiver is not null.
         return null;
       }
       target = receiverClass.lookupLocalMember(name);
       if (target == null) {
+        compiler.backend.registerThrowNoSuchMethod();
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         return warnAndCreateErroneousElement(node, name,
                                              MessageKind.METHOD_NOT_FOUND,
                                              {'className': receiverClass.name,
                                               'methodName': name});
       } else if (target.isInstanceMember()) {
         error(node, MessageKind.MEMBER_NOT_STATIC,
               {'className': receiverClass.name,
                'memberName': name});
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (Elements.isUnresolved(target)) {
+        compiler.backend.registerThrowNoSuchMethod();
         return warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
             {'libraryName': prefix.name, 'memberName': name});
       } else if (target.kind == ElementKind.CLASS) {
         ClassElement classElement = target;
         classElement.ensureResolved(compiler);
       }
     }
     return target;
   }
@@ skipping 90 matching lines @@
     }
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
     if (!Elements.isUnresolved(target)
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
       if (target == null && !inInstanceContext) {
+        compiler.backend.registerThrowNoSuchMethod();
         target =
             warnAndCreateErroneousElement(node.selector, field.name,
                                           MessageKind.CANNOT_RESOLVE_GETTER);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
-      if (identical(operatorString, 'is') || identical(operatorString, 'as')) {
+      if (operatorString == 'is' || operatorString == 'as') {

[ahe, 2013/02/18 12:38:04]

This has to be identical.

         assert(node.arguments.tail.isEmpty);
         DartType type = resolveTypeTest(node.arguments.head);
         if (type != null) {
-          compiler.enqueuer.resolution.registerIsCheck(type);
+          if (operatorString == 'as') {

[ahe, 2013/02/18 12:38:04]

Identical.

+            compiler.enqueuer.resolution.registerAsCheck(type);
+          } else {
+            compiler.enqueuer.resolution.registerIsCheck(type);
+          }
         }
         resolvedArguments = true;
       } else if (identical(operatorString, '?')) {
         Element parameter = mapping[node.receiver];
         if (parameter == null
             || !identical(parameter.kind, ElementKind.PARAMETER)) {
           error(node.receiver, MessageKind.PARAMETER_NAME_EXPECTED);
         } else {
           mapping.checkedParameters.add(parameter);
         }
@@ skipping 38 matching lines @@
     useElement(node, target);
     registerSend(selector, target);
     if (node.isPropertyAccess) {
       // It might be the closurization of a method.
       world.registerInstantiatedClass(compiler.functionClass);
     }
     return node.isPropertyAccess ? target : null;
   }
 
   void warnArgumentMismatch(Send node, Element target) {
+    compiler.backend.registerThrowNoSuchMethod();
     // TODO(karlklose): we can be more precise about the reason of the
     // mismatch.
     warning(node.argumentsNode, MessageKind.INVALID_ARGUMENTS,
             {'methodName': target.name});
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(String typeName) {
     Element element = scope.lookup(new SourceString(typeName));
     if (element == null) return null;
     if (element is! ClassElement) return null;
     element.ensureResolved(compiler);
     return element.computeType(compiler);
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
     Element setter = target;
     Element getter = target;
     SourceString operatorName = node.assignmentOperator.source;
     String source = operatorName.stringValue;
     bool isComplex = !identical(source, '=');
-    if (!Elements.isUnresolved(target)
-        && target.kind == ElementKind.ABSTRACT_FIELD) {
-      AbstractFieldElement field = target;
-      setter = field.setter;
-      getter = field.getter;
-      if (setter == null && !inInstanceContext) {
-        setter =
-            warnAndCreateErroneousElement(node.selector, field.name,
-                                          MessageKind.CANNOT_RESOLVE_SETTER);
-      }
-      if (isComplex && getter == null && !inInstanceContext) {
-        getter =
-            warnAndCreateErroneousElement(node.selector, field.name,
-                                          MessageKind.CANNOT_RESOLVE_GETTER);
+    if (!Elements.isUnresolved(target)) {
+      if (target.isAbstractField()) {
+        AbstractFieldElement field = target;
+        setter = field.setter;
+        getter = field.getter;
+        if (setter == null && !inInstanceContext) {
+          setter =
+              warnAndCreateErroneousElement(node.selector, field.name,
+                                            MessageKind.CANNOT_RESOLVE_SETTER);
+          compiler.backend.registerThrowNoSuchMethod();
+        }
+        if (isComplex && getter == null && !inInstanceContext) {
+          getter =
+              warnAndCreateErroneousElement(node.selector, field.name,
+                                            MessageKind.CANNOT_RESOLVE_GETTER);
+          compiler.backend.registerThrowNoSuchMethod();
+        }
+      } else if (target.impliesType()) {
+        compiler.backend.registerThrowNoSuchMethod();
       }
     }
 
     visit(node.argumentsNode);
 
     // TODO(ngeoffray): Check if the target can be assigned.
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
 
     Selector selector = mapping.getSelector(node);
@@ skipping 131 matching lines @@
     }
     world.registerStaticUse(redirectionTarget);
     world.registerInstantiatedClass(
         redirectionTarget.enclosingElement.declaration);
   }
 
   visitThrow(Throw node) {
     if (!inCatchBlock && node.expression == null) {
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
+    compiler.backend.registerThrow();
     visit(node.expression);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     VariableDefinitionsVisitor visitor =
         new VariableDefinitionsVisitor(compiler, node, this,
                                        ElementKind.VARIABLE);
     // Ensure that we set the type of the [VariableListElement] since it depends
     // on the current scope. If the current scope is a [MethodScope] or
     // [BlockScope] it will not be available for the
@@ skipping 15 matching lines @@
     visit(node.expression);
   }
 
   visitNewExpression(NewExpression node) {
     Node selector = node.send.selector;
     FunctionElement constructor = resolveConstructor(node);
     resolveSelector(node.send);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
-    // TODO(karlklose): handle optional arguments.
-    if (node.send.argumentCount() != constructor.parameterCount(compiler)) {
-      // TODO(ngeoffray): resolution error with wrong number of
-      // parameters. We cannot do this rigth now because of the
-      // List constructor.
+    Selector callSelector = mapping.getSelector(node.send);
+    if (!callSelector.applies(constructor, compiler)) {
+      warnArgumentMismatch(node.send, constructor);

[ahe, 2013/02/18 12:38:04]

I would prefer if you did this change separately and tested it.

+      compiler.backend.registerThrowNoSuchMethod();
     }
     // [constructor] might be the implementation element and only declaration
     // elements may be registered.
     world.registerStaticUse(constructor.declaration);
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
     // [constructor.defaultImplementation] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.defaultImplementation.declaration);
     ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
     // [cls] might be the implementation element and only declaration elements
     // may be registered.
     world.registerInstantiatedClass(cls.declaration);
+    if (cls.isAbstract(compiler)) {
+      compiler.backend.registerAbstractClassInstantiation();
+    }
     // [cls] might be the declaration element and we want to include injected
     // members.
     cls.implementation.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         },
         includeBackendMembers: false,
         includeSuperMembers: true);
     return null;
   }
@@ skipping 82 matching lines @@
     }
     visit(node.elements);
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
 
   visitStringInterpolation(StringInterpolation node) {
     world.registerInstantiatedClass(compiler.stringClass);
+    compiler.backend.registerStringInterpolation();
     node.visitChildren(this);
   }
 
   visitStringInterpolationPart(StringInterpolationPart node) {
     registerImplicitInvocation(const SourceString('toString'), 0);
     node.visitChildren(this);
   }
 
   visitBreakStatement(BreakStatement node) {
     TargetElement target;
@@ skipping 120 matching lines @@
     });
     if (!targetElement.isTarget && identical(mapping[body], targetElement)) {
       // If the body is itself a break or continue for another target, it
       // might have updated its mapping to the target it actually does target.
       mapping.remove(body);
     }
   }
 
   visitLiteralMap(LiteralMap node) {
     world.registerInstantiatedClass(compiler.mapClass);
+    if (node.isConst()) {
+      compiler.backend.registerConstantMap();
+    }
     node.visitChildren(this);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 57 matching lines @@
 
     // Clean-up unused labels.
     continueLabels.forEach((String key, LabelElement label) {
       if (!label.isContinueTarget) {
         TargetElement targetElement = label.target;
         SwitchCase switchCase = targetElement.statement;
         mapping.remove(switchCase);
         mapping.remove(label.label);
       }
     });
+    // TODO(ngeoffray): We should check here instead of the SSA backend if
+    // there might be an error.
+    compiler.backend.registerFallThroughError();
   }
 
   visitSwitchCase(SwitchCase node) {
     node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(scope));
   }
 
   visitCaseMatch(CaseMatch node) {
     visit(node.expression);
   }
 
   visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
       // TODO(ngeoffray): The precise location is
       // node.getEndtoken.next. Adjust when issue #1581 is fixed.
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
 
   visitCatchBlock(CatchBlock node) {
+    compiler.backend.registerCatchStatement();
     // Check that if catch part is present, then
     // it has one or two formal parameters.
     if (node.formals != null) {
       if (node.formals.isEmpty) {
         error(node, MessageKind.EMPTY_CATCH_DECLARATION);
       }
-      if (!node.formals.nodes.tail.isEmpty &&
-          !node.formals.nodes.tail.tail.isEmpty) {
-        for (Node extra in node.formals.nodes.tail.tail) {
-          error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
+      if (!node.formals.nodes.tail.isEmpty) {
+        if (!node.formals.nodes.tail.tail.isEmpty) {

[ahe, 2013/02/18 12:38:04]

Generally, I really like going from && to nested ifs. It is just more readable
to me.

+          for (Node extra in node.formals.nodes.tail.tail) {
+            error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
+          }
         }
+        compiler.backend.registerStackTraceInCatch();
       }
 
       // Check that the formals aren't optional and that they have no
       // modifiers or type.
       for (Link<Node> link = node.formals.nodes;
            !link.isEmpty;
            link = link.tail) {
         // If the formal parameter is a node list, it means that it is a
         // sequence of optional parameters.
         NodeList nodeList = link.head.asNodeList();
         if (nodeList != null) {
           error(nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
         } else {
-        VariableDefinitions declaration = link.head;
+          VariableDefinitions declaration = link.head;
           for (Node modifier in declaration.modifiers.nodes) {
             error(modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
           }
           TypeAnnotation type = declaration.type;
           if (type != null) {
             error(type, MessageKind.PARAMETER_WITH_TYPE_IN_CATCH);
           }
         }
       }
     }
@@ skipping 744 matching lines @@
 
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
                                SourceString targetName, MessageKind kind,
                                Map arguments) {
+    if (kind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
+      compiler.backend.registerThrowNoSuchMethod();
+    } else {
+      compiler.backend.registerThrowRuntimeError();
+    }
     if (inConstContext) {
       error(diagnosticNode, kind, arguments);
     } else {
       ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
       compiler.reportWarning(diagnosticNode, warning);
       return new ErroneousElementX(kind, arguments, targetName, enclosing);
     }
   }
 
   Selector createConstructorSelector(SourceString constructorName) {
@@ skipping 128 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }