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 133 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);
-      }
-      graph.calledInLoop = inLoop;
+      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.
-      List<HType> parameterTypes =
-          backend.optimisticParameterTypesWithRecompilationOnTypeChange(
-              element);
-      if (parameterTypes != null) {
-        FunctionSignature signature = element.computeSignature(compiler);
-        int i = 0;
-        signature.forEachParameter((Element param) {
-          builder.parameters[param].guaranteedType = parameterTypes[i++];
-        });
+        // If there is an estimate of the parameter types assume these types
+        // when compiling.
+        List<HType> parameterTypes =
+            backend.optimisticParameterTypesWithRecompilationOnTypeChange(
+                element);
+        if (parameterTypes != null) {
+          FunctionElement functionElement = element;
+          FunctionSignature signature =
+              functionElement.computeSignature(compiler);
+          int i = 0;
+          signature.forEachParameter((Element param) {
+            builder.parameters[param].guaranteedType = parameterTypes[i++];
+          });
+        }
       }
 
       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 119 matching lines @@
       HInstruction fieldGet = new HFieldGet.withElement(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.withElement(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.withElement(redirect, box, value));
     } else {
       assert(isUsedInTry(element));
       HLocalValue local = getLocal(element);
       builder.add(new HLocalSet(element, local, value));
     }
   }
 
   /**
@@ skipping 354 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;
   }
 
   void inlineSuperOrRedirect(FunctionElement constructor,
                              Selector selector,
                              Link<Node> arguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues) {
     constructors.addLast(constructor);
 
@@ skipping 134 matching lines @@
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
       HInstruction value = fieldValues[member];
       if (value === null) {
         // The field has no value in the initializer list. Initialize it
         // with the declaration-site constant (if any).
-        Constant fieldValue = compiler.constantHandler.compileVariable(member);
+        Constant fieldValue = compiler.compileConstant(member);
         value = graph.addConstant(fieldValue);
       }
       constructorArguments.add(value);
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
@@ skipping 493 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 178 matching lines @@
       add(target);
       List<HInstruction> inputs = <HInstruction>[target, receiver];
       push(new HInvokeInterceptor(selector, getterName, inputs, getter: true));
     } else {
       push(new HInvokeDynamicGetter(selector, null, getterName, receiver));
     }
   }
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
-      if (element.kind == ElementKind.FIELD && !element.isAssignable()) {
-        // A static final. 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 20 matching lines @@
           selector, dartSetterName, inputs, setter: true));
     } else {
       add(new HInvokeDynamicSetter(selector, null, dartSetterName,
                                    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 71 matching lines @@
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
 
       Type 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 frog behavior 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 64 matching lines @@
   bool addStaticSendArgumentsToList(Selector selector,
                                     Link<Node> arguments,
                                     FunctionElement element,
                                     List<HInstruction> list) {
     HInstruction compileArgument(Node argument) {
       visit(argument);
       return pop();
     }
 
     HInstruction compileConstant(Element constantElement) {
-      Constant constant = compiler.compileVariable(constantElement);
+      Constant constant = compiler.compileConstant(constantElement);
       return graph.addConstant(constant);
     }
 
     return selector.addArgumentsToList(arguments,
                                        list,
                                        element,
                                        compileArgument,
                                        compileConstant,
                                        compiler);
   }
@@ skipping 257 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 936 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 
+            // type of declared variable won't matter for the catch
             // condition

[kasperl, 2012/08/17 09:30:04]

Terminate comment with .

[floitsch, 2012/09/04 17:32:21]

Done.

             Type 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 382 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;
   }
 }