Lazy implementation of final variables.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 137 matching lines @@
   SsaBuilderTask(JavaScriptBackend backend)
     : interceptors = new Interceptors(backend.compiler),
       emitter = backend.emitter,
       functionsCalledInLoop = new Set<FunctionElement>(),
       selectorsCalledInLoop = new Map<SourceString, Selector>(),
       backend = backend,
       super(backend.compiler);
 
   HGraph build(WorkItem work) {
     return measure(() {
-      FunctionElement element = work.element;
+      Element element = work.element;
       HInstruction.idCounter = 0;
       SsaBuilder builder = new SsaBuilder(this, work);
       HGraph graph;
       ElementKind kind = element.kind;
       if (kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
         graph = compileConstructor(builder, work);
       } else if (kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
                  kind === ElementKind.FUNCTION ||
                  kind === ElementKind.GETTER ||
                  kind === ElementKind.SETTER) {
         graph = builder.buildMethod(work.element);
+      } else if (kind === ElementKind.FIELD) {
+        graph = builder.buildLazyInitializer(work.element);
       }
       assert(graph.isValid());
-      bool inLoop = functionsCalledInLoop.contains(element);
-      if (!inLoop) {
-        Selector selector = selectorsCalledInLoop[element.name];
-        inLoop = selector !== null && selector.applies(element, compiler);
+      if (kind !== ElementKind.FIELD) {
+        bool inLoop = functionsCalledInLoop.contains(element);
+        if (!inLoop) {
+          Selector selector = selectorsCalledInLoop[element.name];
+          inLoop = selector !== null && selector.applies(element, compiler);
+        }
+        graph.calledInLoop = inLoop;
+
+        // If there is an estimate of the parameter types assume these types
+        // when compiling.
+        HTypeList parameterTypes =
+            backend.optimisticParameterTypes(
+                element);
+        if (!parameterTypes.allUnknown) {
+          FunctionElement functionElement = element;
+          FunctionSignature signature =
+              functionElement.computeSignature(compiler);
+          int i = 0;
+          signature.forEachParameter((Element param) {
+            builder.parameters[param].guaranteedType = parameterTypes[i++];
+          });
+        }
+        backend.registerParameterTypesOptimization(element, parameterTypes);
       }
-      graph.calledInLoop = inLoop;
-
-      // If there is an estimate of the parameter types assume these types when
-      // compiling.
-      HTypeList parameterTypes =
-          backend.optimisticParameterTypes(
-              element);
-      if (!parameterTypes.allUnknown) {
-        FunctionSignature signature = element.computeSignature(compiler);
-        int i = 0;
-        signature.forEachParameter((Element param) {
-          builder.parameters[param].guaranteedType = parameterTypes[i++];
-        });
-      }
-      backend.registerParameterTypesOptimization(element, parameterTypes);
 
       if (compiler.tracer.enabled) {
         String name;
         if (element.isMember()) {
           String className = element.getEnclosingClass().name.slowToString();
           String memberName = element.name.slowToString();
           name = "$className.$memberName";
-          if (element.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
+          if (element.isGenerativeConstructorBody()) {
             name = "$name (body)";
           }
         } else {
           name = "${element.name.slowToString()}";
         }
         compiler.tracer.traceCompilation(name, work.compilationContext);
         compiler.tracer.traceGraph('builder', graph);
       }
       return graph;
     });
@@ skipping 71 matching lines @@
       // TODO(floitsch): Clean up this hack. Should we create a box-object by
       // just creating an empty object literal?
       HInstruction box = createBox();
       // Add the box to the known locals.
       directLocals[scopeData.boxElement] = box;
       // Make sure that accesses to the boxed locals go into the box. We also
       // need to make sure that parameters are copied into the box if necessary.
       scopeData.capturedVariableMapping.forEach((Element from, Element to) {
         // The [from] can only be a parameter for function-scopes and not
         // loop scopes.
-        if (from.kind == ElementKind.PARAMETER) {
+        if (from.isParameter()) {
           // Store the captured parameter in the box. Get the current value
           // before we put the redirection in place.
           HInstruction instruction = readLocal(from);
           redirectElement(from, to);
           // Now that the redirection is set up, the update to the local will
           // write the parameter value into the box.
           updateLocal(from, instruction);
         } else {
           redirectElement(from, to);
         }
@@ skipping 118 matching lines @@
       HInstruction fieldGet = new HFieldGet(redirect, receiver);
       builder.add(fieldGet);
       return fieldGet;
     } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
-      assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
+      assert(redirect.enclosingElement.isVariable());
       HInstruction box = readLocal(redirect.enclosingElement);
       HInstruction lookup = new HFieldGet(redirect, box);
       builder.add(lookup);
       return lookup;
     } else {
       assert(isUsedInTry(element));
       HLocalValue local = getLocal(element);
       HInstruction variable = new HLocalGet(element, local);
       builder.add(variable);
       return variable;
@@ skipping 39 matching lines @@
   void updateLocal(Element element, HInstruction value) {
     assert(!isStoredInClosureField(element));
     if (isAccessedDirectly(element)) {
       directLocals[element] = value;
     } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
-      assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
+      assert(redirect.enclosingElement.isVariable());
       HInstruction box = readLocal(redirect.enclosingElement);
       builder.add(new HFieldSet(redirect, box, value));
     } else {
       assert(isUsedInTry(element));
       HLocalValue local = getLocal(element);
       builder.add(new HLocalSet(element, local, value));
     }
   }
 
   /**
@@ skipping 320 matching lines @@
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // The most recently opened block. Has the same value as [current] while
   // the block is open, but unlike [current], it isn't cleared when the current
   // block is closed.
   HBasicBlock lastOpenedBlock;
 
   LibraryElement get currentLibrary => work.element.getLibrary();
+  Element get currentElement => work.element;
   Compiler get compiler => builder.compiler;
   CodeEmitterTask get emitter => builder.emitter;
 
   SsaBuilder(SsaBuilderTask builder, WorkItem work)
     : this.builder = builder,
       this.work = work,
       interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
@@ skipping 20 matching lines @@
     methodInterceptionEnabled = true;
   }
 
   HGraph buildMethod(FunctionElement functionElement) {
     FunctionExpression function = functionElement.parseNode(compiler);
     openFunction(functionElement, function);
     function.body.accept(this);
     return closeFunction();
   }
 
+  HGraph buildLazyInitializer(VariableElement variable) {
+    HBasicBlock block = graph.addNewBlock();
+    open(graph.entry);
+    close(new HGoto()).addSuccessor(block);
+    open(block);
+    SendSet node = variable.parseNode(compiler);
+    Link<Node> link = node.arguments;
+    assert(!link.isEmpty() && link.tail.isEmpty());
+    visit(link.head);
+    close(new HReturn(pop())).addSuccessor(graph.exit);
+    graph.finalize();
+    return graph;
+  }
+
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
   ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
-    assert(constructor.kind === ElementKind.GENERATIVE_CONSTRUCTOR);
+    assert(constructor.isGenerativeConstructor());
     if (constructor is SynthesizedConstructorElement) return null;
     FunctionExpression node = constructor.parseNode(compiler);
     // If we know the body doesn't have any code, we don't generate
     // it.
     if (node.body.asBlock() !== null) {
       NodeList statements = node.body.asBlock().statements;
       if (statements.isEmpty()) return null;
     }
     ClassElement classElement = constructor.getEnclosingClass();
     ConstructorBodyElement bodyElement;
     for (Link<Element> backendMembers = classElement.backendMembers;
          !backendMembers.isEmpty();
          backendMembers = backendMembers.tail) {
       Element backendMember = backendMembers.head;
-      if (backendMember.kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
+      if (backendMember.isGenerativeConstructorBody()) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           bodyElement = backendMember;
           break;
         }
       }
     }
     if (bodyElement === null) {
       bodyElement = new ConstructorBodyElement(constructor);
       TreeElements treeElements =
           compiler.resolver.resolveMethodElement(constructor);
       compiler.enqueuer.codegen.addToWorkList(bodyElement, treeElements);
       classElement.backendMembers =
           classElement.backendMembers.prepend(bodyElement);
     }
-    assert(bodyElement.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY);
+    assert(bodyElement.isGenerativeConstructorBody());
     return bodyElement;
   }
 
   InliningState enterInlinedMethod(PartialFunctionElement function,
                                    Selector selector,
                                    Link<Node> arguments) {
     // Once we start to compile the arguments we must be sure that we don't
     // abort.
     List<HInstruction> compiledArguments = new List<HInstruction>();
     bool succeeded = addStaticSendArgumentsToList(selector,
@@ skipping 28 matching lines @@
     stack.add(localsHandler.readLocal(returnElement));
     returnElement = state.oldReturnElement;
     assert(stack.length == 1);
     state.oldStack.add(stack[0]);
     stack = state.oldStack;
   }
 
   bool tryInlineMethod(Element element,
                        Selector selector,
                        Link<Node> arguments) {
-    if (element.kind != ElementKind.FUNCTION) return false;
+    // TODO(floitsch): we should be able to inline inside lazy initializers.
+    if (!currentElement.isFunction()) return false;
+    // TODO(floitsch): we should be able to inline getters, setters and
+    // constructor bodies.
+    if (!element.isFunction()) return false;
     // TODO(floitsch): find a cleaner way to know if the element is a function
     // containing nodes.
     // [PartialFunctionElement]s are [FunctionElement]s that have [Node]s.
     if (element is !PartialFunctionElement) return false;
     if (inliningStack.length > MAX_INLINING_DEPTH) return false;
     // Don't inline recursive calls. We use the same elements for the inlined
     // functions and would thus clobber our local variables.
     if (work.element == element) return false;
     for (int i = 0; i < inliningStack.length; i++) {
       if (inliningStack[i].function == element) return false;
@@ skipping 800 matching lines @@
     // TODO(ahe): This should be registered in codegen, not here.
     compiler.enqueuer.codegen.addToWorkList(callElement, elements);
     // TODO(ahe): This should be registered in codegen, not here.
     compiler.enqueuer.codegen.registerInstantiatedClass(closureClassElement);
     assert(closureClassElement.localScope.isEmpty());
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     for (Element member in closureClassElement.backendMembers) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
-      if (member.kind == ElementKind.FIELD) {
+      if (member.isField()) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     }
 
     push(new HForeignNew(closureClassElement, capturedVariables));
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
@@ skipping 194 matching lines @@
       add(target);
       List<HInstruction> inputs = <HInstruction>[target, receiver];
       push(new HInvokeInterceptor(selector, inputs));
     } else {
       push(new HInvokeDynamicGetter(selector, null, receiver));
     }
   }
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
-      if (element.kind == ElementKind.FIELD && !element.isAssignable()) {
-        // A static const. Get its constant value and inline it.
-        Constant value = compiler.constantHandler.compileVariable(element);
+      Constant value;
+      if (element.isField() && !element.isAssignable()) {
+        // A static final or const. Get its constant value and inline it if
+        // the value can be compiled eagerly.
+        value = compiler.compileVariable(element);
+      }
+      if (value != null) {
         stack.add(graph.addConstant(value));
+      } else if (element.isField() && compiler.isLazilyInitialized(element)) {
+        push(new HLazyStatic(element));
       } else {
         push(new HStatic(element));
-        if (element.kind == ElementKind.GETTER) {
+        if (element.isGetter()) {
           push(new HInvokeStatic(<HInstruction>[pop()]));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       push(new HStatic(element));
       // TODO(ahe): This should be registered in codegen.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
@@ skipping 19 matching lines @@
       List<HInstruction> inputs = <HInstruction>[target, receiver, value];
       add(new HInvokeInterceptor(selector, inputs));
     } else {
       add(new HInvokeDynamicSetter(selector, null, receiver, value));
     }
     stack.add(value);
   }
 
   void generateSetter(SendSet send, Element element, HInstruction value) {
     if (Elements.isStaticOrTopLevelField(element)) {
-      if (element.kind == ElementKind.SETTER) {
+      if (element.isSetter()) {
         HStatic target = new HStatic(element);
         add(target);
         add(new HInvokeStatic(<HInstruction>[target, value]));
       } else {
         add(new HStaticStore(element, value));
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
@@ skipping 80 matching lines @@
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
 
       DartType type = elements.getType(typeAnnotation);
       HInstruction typeInfo = null;
       if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
         pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(), expression);
         typeInfo = pop();
       }
-      if (type.element.kind === ElementKind.TYPE_VARIABLE) {
+      if (type.element.isTypeVariable()) {
         // TODO(karlklose): We emulate the behavior of the old frog
         // compiler and answer true to any is check involving a type variable
         // -- both is T and is !T -- until we have a proper implementation of
         // reified generics.
         stack.add(graph.addConstantBool(true));
       } else {
         HInstruction instruction;
         if (typeInfo !== null) {
           instruction = new HIs.withTypeInfoCall(type, expression, typeInfo);
         } else {
@@ skipping 70 matching lines @@
       return pop();
     }
 
     HInstruction compileConstant(Element parameter) {
       Constant constant;
       TreeElements calleeElements =
           compiler.enqueuer.resolution.getCachedElements(element);
       if (calleeElements.isParameterChecked(parameter)) {
         constant = SentinelConstant.SENTINEL;
       } else {
-        constant = compiler.compileVariable(parameter);
+        constant = compiler.compileConstant(parameter);
       }
       return graph.addConstant(constant);
     }
 
     return selector.addArgumentsToList(arguments,
                                        list,
                                        element,
                                        compileArgument,
                                        compileConstant,
                                        compiler);
@@ skipping 255 matching lines @@
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === null) return generateSuperNoSuchMethodSend(node);
     HInstruction target = new HStatic(element);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (node.isPropertyAccess) {
       push(new HInvokeSuper(inputs));
-    } else if (element.kind == ElementKind.FUNCTION ||
-               element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
+    } else if (element.isFunction() || element.isGenerativeConstructor()) {
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node);
       }
       push(new HInvokeSuper(inputs));
     } else {
       target = new HInvokeSuper(inputs);
@@ skipping 85 matching lines @@
     pushWithPosition(newInstance, node);
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === compiler.assertMethod && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull());
       return;
     }
-    compiler.ensure(element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR);
+    compiler.ensure(!element.isGenerativeConstructor());
+    if (element.isFunction()) {
+      if (tryInlineMethod(element, selector, node.arguments)) return;
 
-    if (tryInlineMethod(element, selector, node.arguments)) return;
-
-    HInstruction target = new HStatic(element);
-    add(target);
-    var inputs = <HInstruction>[];
-    inputs.add(target);
-    if (element.kind == ElementKind.FUNCTION) {
+      HInstruction target = new HStatic(element);
+      add(target);
+      var inputs = <HInstruction>[target];
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element, inputs);
       if (!succeeded) {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented non-matching static call', node: node);
       }
       HInvokeStatic instruction = new HInvokeStatic(inputs);
       // TODO(ngeoffray): Only do this if knowing the return type is
       // useful.
       HType returnType =
           builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
               work.element, element);
       if (returnType != null) instruction.guaranteedType = returnType;
       pushWithPosition(instruction, node);
     } else {
-      if (element.kind == ElementKind.GETTER) {
-        target = new HInvokeStatic(inputs);
-        add(target);
-        inputs = <HInstruction>[target];
-      }
+      generateGetter(node, element);
+      List<HInstruction> inputs = <HInstruction>[pop()];
       addDynamicSendArgumentsToList(node, inputs);
       pushWithPosition(new HInvokeClosure(selector, inputs), node);
     }
   }
 
   visitGetterSend(Send node) {
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaBuilder to internalError.
@@ skipping 861 matching lines @@
         else {
           VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
-            // condition
+            // condition.
             DartType type = elements.getType(declaration.type);
             if (type == null) {
               compiler.cancel('Catch with unresolved type', node: catchBlock);
             }
             condition = new HIs(type, unwrappedException, nullOk: true);
             push(condition);
           }
         }
       }
 
@@ skipping 464 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;
   }
 }