Start tracking all registered elements in one big full function set

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 232 matching lines @@
       updateLocal(boxElement, oldBox);
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   HType cachedTypeOfThis;
 
-  HType computeTypeOfThis() {
-    Element element = closureData.thisElement;
-    ClassElement cls = element.enclosingElement.getEnclosingClass();
-    Compiler compiler = builder.compiler;
-    DartType type = cls.computeType(compiler);
-    if (compiler.world.isUsedAsMixin(cls)) {
-      // If the enclosing class is used as a mixin, [:this:] can be
-      // of the class that mixins the enclosing class. These two
-      // classes do not have a subclass relationship, so, for
-      // simplicity, we mark the type as an interface type.
-      cachedTypeOfThis = new HType.nonNullSubtype(type, compiler);
-    } else {
-      cachedTypeOfThis = new HType.nonNullSubclass(type, compiler);
+  HType getTypeOfThis() {
+    HType result = cachedTypeOfThis;
+    if (result == null) {
+      Element element = closureData.thisElement;
+      ClassElement cls = element.enclosingElement.getEnclosingClass();
+      Compiler compiler = builder.compiler;
+      DartType type = cls.computeType(compiler);
+      if (compiler.world.isUsedAsMixin(cls)) {
+        // If the enclosing class is used as a mixin, [:this:] can be
+        // of the class that mixins the enclosing class. These two
+        // classes do not have a subclass relationship, so, for
+        // simplicity, we mark the type as an interface type.
+        result = new HType.nonNullSubtype(type, compiler);
+      } else {
+        result = new HType.nonNullSubclass(type, compiler);
+      }
+      cachedTypeOfThis = result;
     }
-    return cachedTypeOfThis;
+    return result;
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [function] must be an implementation element.
    */
   void startFunction(Element element, Expression node) {
     assert(invariant(node, element.isImplementation));
     Compiler compiler = builder.compiler;
@@ skipping 35 matching lines @@
       HThis thisInstruction = new HThis(closureData.thisElement);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember()
                || element.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(
-          closureData.thisElement, computeTypeOfThis());
+          closureData.thisElement, getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver.
     ClassElement cls = element.getEnclosingClass();
     if (builder.backend.isInterceptorClass(cls)) {
       HType type = HType.UNKNOWN;
@@ skipping 94 matching lines @@
       HLocalValue local = getLocal(element);
       HInstruction variable = new HLocalGet(element, local);
       builder.add(variable);
       return variable;
     }
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType == null) {
-      if (cachedTypeOfThis == null) {
-        computeTypeOfThis();
-      }
-      res.guaranteedType = cachedTypeOfThis;
+      res.guaranteedType = getTypeOfThis();
     }
     return res;
   }
 
   HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
@@ skipping 1863 matching lines @@
         return;
       default:
         compiler.internalError("Unexpected operator $op", node: op);
         break;
     }
 
     pushWithPosition(
           buildInvokeDynamic(send, selector, left, [right]),
           op);
     if (op.source.stringValue == '!=') {
-      HBoolify bl = new HBoolify(pop());
-      add(bl);
-      pushWithPosition(new HNot(bl), op);
+      pushWithPosition(new HNot(popBoolified()), op);
     }
   }
 
   HInstruction generateInstanceSendReceiver(Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
@@ skipping 444 matching lines @@
                                        compiler);
   }
 
   void addGenericSendArgumentsToList(Link<Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
       list.add(pop());
     }
   }
 
-  visitDynamicSend(Send node) {
+  bool isThisSend(Send send) {
+    Node receiver = send.receiver;
+    if (receiver == null) return true;
+    Identifier identifier = receiver.asIdentifier();
+    return identifier != null && identifier.isThis();
+  }
+
+  visitDynamicSend(Send node, {bool inline: true}) {
     Selector selector = elements.getSelector(node);
 
-    SourceString dartMethodName;
-    bool isNotEquals = false;
-    if (node.isIndex && !node.arguments.tail.isEmpty) {
-      dartMethodName = Elements.constructOperatorName(
-          const SourceString('[]='), false);
-    } else if (node.selector.asOperator() != null) {
-      SourceString name = node.selector.asIdentifier().source;
-      isNotEquals = identical(name.stringValue, '!=');
-      dartMethodName = Elements.constructOperatorName(
-          name, node.argumentsNode is Prefix);
-    } else {
-      dartMethodName = node.selector.asIdentifier().source;
+    // TODO(kasperl): It would be much better to try to get the
+    // guaranteed type of the receiver after we've evaluated it, but
+    // because of the way inlining currently works that is hard to do
+    // with re-evaluating the receiver.
+    if (isThisSend(node)) {
+      HType receiverType = localsHandler.getTypeOfThis();
+      selector = receiverType.refine(selector, compiler);
     }
 
-    Element element = elements[node];
+    Element element = compiler.world.locateSingleElement(selector);
     bool isClosureCall = false;
-    if (element != null && compiler.world.hasNoOverridingMember(element)) {
+    if (inline && element != null) {
       if (tryInlineMethod(element, selector, node.arguments, node)) {
         if (element.isGetter()) {
           // If the element is a getter, we are doing a closure call
           // on what this getter returns.
           assert(selector.isCall());
           isClosureCall = true;
         } else {
           return;
         }
       }
@@ skipping 16 matching lines @@
 
     HInstruction invoke;
     if (isClosureCall) {
       Selector closureSelector = new Selector.callClosureFrom(selector);
       invoke = new HInvokeClosure(closureSelector, inputs);
     } else {
       invoke = buildInvokeDynamic(node, selector, receiver, inputs);
     }
 
     pushWithPosition(invoke, node);
-
-    if (isNotEquals) {
-      HNot not = new HNot(popBoolified());
-      push(not);
-    }
   }
 
   visitClosureSend(Send node) {
     Selector selector = elements.getSelector(node);
     assert(node.receiver == null);
     Element element = elements[node];
     HInstruction closureTarget;
     if (element == null) {
       visit(node.selector);
       closureTarget = pop();
@@ skipping 737 matching lines @@
       add(target);
       var inputs = <HInstruction>[target, context];
       addDynamicSendArgumentsToList(node, inputs);
       if (!identical(node.assignmentOperator.source.stringValue, '=')) {
         compiler.unimplemented('complex super assignment',
                                node: node.assignmentOperator);
       }
       push(new HInvokeSuper(inputs, isSetter: true));
     } else if (node.isIndex) {
       if (const SourceString("=") == op.source) {
-        visitDynamicSend(node);
+        // TODO(kasperl): We temporarily disable inlining because the
+        // code here cannot deal with it yet.
+        visitDynamicSend(node, inline: false);
         HInvokeDynamicMethod method = pop();
         // Push the value.
         stack.add(method.inputs.last);
       } else {
         visit(node.receiver);
         HInstruction receiver = pop();
         visit(node.argumentsNode);
         HInstruction value;
         HInstruction index;
         // Compound assignments are considered as being prefix.
         bool isCompoundAssignment = op.source.stringValue.endsWith('=');
         bool isPrefix = !node.isPostfix;
-        Element getter = elements[node.selector];
         if (isCompoundAssignment) {
           value = pop();
           index = pop();
         } else {
           index = pop();
           value = graph.addConstantInt(1, constantSystem);
         }
 
         HInvokeDynamicMethod left = buildInvokeDynamic(
             node, new Selector.index(), receiver, [index]);
         add(left);
         visitBinary(left, op, value, node);
         value = pop();
         HInvokeDynamicMethod assign = buildInvokeDynamic(
             node, new Selector.indexSet(), receiver, [index, value]);
         add(assign);
         if (isPrefix) {
           stack.add(value);
         } else {
           stack.add(left);
         }
       }
     } else if (const SourceString("=") == op.source) {
-      Element element = elements[node];
       Link<Node> link = node.arguments;
       assert(!link.isEmpty && link.tail.isEmpty);
       visit(link.head);
       HInstruction value = pop();
       generateSetter(node, element, value);
     } else if (identical(op.source.stringValue, "is")) {
       compiler.internalError("is-operator as SendSet", node: op);
     } else {
       assert(const SourceString("++") == op.source ||
              const SourceString("--") == op.source ||
              node.assignmentOperator.source.stringValue.endsWith("="));
-      Element element = elements[node];
       bool isCompoundAssignment = !node.arguments.isEmpty;
       bool isPrefix = !node.isPostfix;  // Compound assignments are prefix.
 
       // [receiver] is only used if the node is an instance send.
       HInstruction receiver = null;
-      Element selectorElement = elements[node];
       if (Elements.isInstanceSend(node, elements)) {
         receiver = generateInstanceSendReceiver(node);
         generateInstanceGetterWithCompiledReceiver(node, receiver);
       } else {
         generateGetter(node, elements[node.selector]);
       }
       HInstruction left = pop();
       HInstruction right;
       if (isCompoundAssignment) {
         visit(node.argumentsNode);
@@ skipping 249 matching lines @@
     void buildInitializer() {
       SourceString iteratorName = const SourceString("iterator");
       Selector selector =
           new Selector.getter(iteratorName, currentElement.getLibrary());
       Set<ClassElement> interceptedClasses = getInterceptedClassesOn(selector);
       visit(node.expression);
       HInstruction receiver = pop();
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
       if (interceptedClasses == null) {
         iterator =
-            new HInvokeDynamicGetter(selector, null, receiver, hasGetter);
+            new HInvokeDynamicGetter(selector, null, receiver, !hasGetter);
       } else {
         HInterceptor interceptor =
             invokeInterceptor(interceptedClasses, receiver, null);
         iterator =
-            new HInvokeDynamicGetter(selector, null, interceptor, hasGetter);
+            new HInvokeDynamicGetter(selector, null, interceptor, !hasGetter);
         // Add the receiver as an argument to the getter call on the
         // interceptor.
         iterator.inputs.add(receiver);
       }
       add(iterator);
     }
     HInstruction buildCondition() {
       SourceString name = const SourceString('moveNext');
       Selector selector = new Selector.call(
           name, currentElement.getLibrary(), 0);
-      bool hasGetter = compiler.world.hasAnyUserDefinedGetter(selector);
       push(new HInvokeDynamicMethod(selector, <HInstruction>[iterator]));
       return popBoolified();
     }
     void buildBody() {
       SourceString name = const SourceString('current');
       Selector call = new Selector.getter(name, currentElement.getLibrary());
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(call);
-      push(new HInvokeDynamicGetter(call, null, iterator, hasGetter));
+      push(new HInvokeDynamicGetter(call, null, iterator, !hasGetter));
 
       Element variable;
       if (node.declaredIdentifier.asSend() != null) {
         variable = elements[node.declaredIdentifier];
       } else {
         assert(node.declaredIdentifier.asVariableDefinitions() != null);
         VariableDefinitions variableDefinitions = node.declaredIdentifier;
         variable = elements[variableDefinitions.definitions.nodes.head];
       }
       HInstruction oldVariable = pop();
@@ skipping 1106 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }