kernel -> ssa: implement if-statements

pkg/compiler/lib/src/ssa/locals_handler.dart

 // Copyright (c) 2016, 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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
@@ skipping 43 matching lines @@
   ///     }
   ///     main() {
   ///       new Foo<String>('foo');
   ///     }
   ///
   /// [instanceType] is not used if it contains type variables, since these
   /// might not be in scope or from the current instance.
   ///
   final InterfaceType instanceType;
 
-  final Compiler compiler;
+  final Compiler _compiler;
 
   LocalsHandler(this.builder, this.executableContext,
-      InterfaceType instanceType, this.compiler)
+      InterfaceType instanceType, this._compiler)
       : this.instanceType =
             instanceType == null || instanceType.containsTypeVariables
                 ? null
                 : instanceType;
 
   /// Substituted type variables occurring in [type] into the context of
   /// [contextClass].
   DartType substInContext(DartType type) {
     if (contextClass != null) {
       ClassElement typeContext = Types.getClassContext(type);
@@ skipping 10 matching lines @@
   /// Creates a new [LocalsHandler] based on [other]. We only need to
   /// copy the [directLocals], since the other fields can be shared
   /// throughout the AST visit.
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Local, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
         executableContext = other.executableContext,
         instanceType = other.instanceType,
         builder = other.builder,
         closureData = other.closureData,
-        compiler = other.compiler,
+        _compiler = other._compiler,
         activationVariables = other.activationVariables,
         cachedTypeOfThis = other.cachedTypeOfThis,
         cachedTypesOfCapturedVariables = other.cachedTypesOfCapturedVariables;
 
   /// Redirects accesses from element [from] to element [to]. The [to] element
   /// must be a boxed variable or a variable that is stored in a closure-field.
   void redirectElement(Local from, CapturedVariable to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
   HInstruction createBox() {
     // TODO(floitsch): Clean up this hack. Should we create a box-object by
     // just creating an empty object literal?
-    JavaScriptBackend backend = compiler.backend;
+    JavaScriptBackend backend = _compiler.backend;
     HInstruction box = new HForeignCode(
         js.js.parseForeignJS('{}'), backend.nonNullType, <HInstruction>[],
         nativeBehavior: native.NativeBehavior.PURE_ALLOCATION);
     builder.add(box);
     return box;
   }
 
   /// If the scope (function or loop) [node] has captured variables then this
   /// method creates a box and sets up the redirections.
   void enterScope(ast.Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
     // we need to create a box-object.
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData == null) return;
     HInstruction box;
     // The scope has captured variables.
     if (element != null && element.isGenerativeConstructorBody) {
       // The box is passed as a parameter to a generative
       // constructor body.
-      JavaScriptBackend backend = compiler.backend;
+      JavaScriptBackend backend = _compiler.backend;
       box = builder.addParameter(scopeData.boxElement, backend.nonNullType);
     } else {
       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.forEachCapturedVariable(
         (LocalVariableElement from, BoxFieldElement to) {
@@ skipping 33 matching lines @@
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   /// Documentation wanted -- johnniwinther
   ///
   /// Invariant: [function] must be an implementation element.
   void startFunction(AstElement element, ast.Node node) {
     assert(invariant(element, element.isImplementation));
-    closureData = compiler.closureToClassMapper
+    closureData = _compiler.closureToClassMapper
         .computeClosureToClassMapping(element.resolvedAst);
 
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature params = functionElement.functionSignature;
       ClosureScope scopeData = closureData.capturingScopes[node];
       params.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
           if (scopeData != null &&
               scopeData.isCapturedVariable(parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction parameter = builder.addParameter(parameterElement,
-            TypeMaskFactory.inferredTypeForElement(parameterElement, compiler));
+            TypeMaskFactory.inferredTypeForElement(parameterElement, _compiler));
         builder.parameters[parameterElement] = parameter;
         directLocals[parameterElement] = parameter;
       });
     }
 
     enterScope(node, element);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.forEachFreeVariable((Local from, CapturedVariable to) {
       redirectElement(from, to);
     });
-    JavaScriptBackend backend = compiler.backend;
+    JavaScriptBackend backend = _compiler.backend;
     if (closureData.isClosure) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction =
           new HThis(closureData.thisLocal, backend.nonNullType);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (element.isInstanceMember) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
@@ skipping 28 matching lines @@
       }
       if (isInterceptorClass) {
         // Only use the extra parameter in intercepted classes.
         directLocals[closureData.thisLocal] = value;
       }
     } else if (isNativeUpgradeFactory) {
       SyntheticLocal parameter =
           new SyntheticLocal('receiver', executableContext);
       // Unlike `this`, receiver is nullable since direct calls to generative
       // constructor call the constructor with `null`.
-      ClassWorld classWorld = compiler.world;
+      ClassWorld classWorld = _compiler.world;
       HParameterValue value =
           new HParameterValue(parameter, new TypeMask.exact(cls, classWorld));
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAtEntry(value);
     }
   }
 
   /// Returns true if the local can be accessed directly. Boxed variables or
   /// captured variables that are stored in the closure-field return [:false:].
   bool isAccessedDirectly(Local local) {
@@ skipping 20 matching lines @@
     return closureData.variablesUsedInTryOrGenerator.contains(local);
   }
 
   /// Returns an [HInstruction] for the given element. If the element is
   /// boxed or stored in a closure then the method generates code to retrieve
   /// the value.
   HInstruction readLocal(Local local, {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableElement) {
-          compiler.reporter.internalError(compiler.currentElement,
+          _compiler.reporter.internalError(_compiler.currentElement,
               "Runtime type information not available for $local.");
         } else {
-          compiler.reporter.internalError(
+          _compiler.reporter.internalError(
               local, "Cannot find value $local in ${directLocals.keys}.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
       HInstruction receiver = readLocal(closureData.closureElement);
       TypeMask type = local is BoxLocal
-          ? (compiler.backend as JavaScriptBackend).nonNullType
+          ? (_compiler.backend as JavaScriptBackend).nonNullType
           : getTypeOfCapturedVariable(redirect);
       HInstruction fieldGet = new HFieldGet(redirect, receiver, type);
       builder.add(fieldGet);
       return fieldGet..sourceInformation = sourceInformation;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // 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.
       HInstruction box = readLocal(redirect.box);
       HInstruction lookup =
           new HFieldGet(redirect, box, getTypeOfCapturedVariable(redirect));
       builder.add(lookup);
       return lookup..sourceInformation = sourceInformation;
     } else {
       assert(isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       HInstruction instruction = new HLocalGet(
           local,
           localValue,
-          (compiler.backend as JavaScriptBackend).dynamicType,
+          (_compiler.backend as JavaScriptBackend).dynamicType,
           sourceInformation);
       builder.add(instruction);
       return instruction;
     }
   }
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisLocal);
     if (res.instructionType == null) {
       res.instructionType = getTypeOfThis();
     }
     return res;
   }
 
   HLocalValue getLocal(Local local, {SourceInformation sourceInformation}) {
     // 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.
     if (local is ParameterElement) {
       assert(invariant(local, builder.parameters.containsKey(local),
           message: "No local value for parameter $local in "
               "${builder.parameters}."));
       return builder.parameters[local];
     }
 
     return activationVariables.putIfAbsent(local, () {
-      JavaScriptBackend backend = compiler.backend;
+      JavaScriptBackend backend = _compiler.backend;
       HLocalValue localValue = new HLocalValue(local, backend.nonNullType)
         ..sourceInformation = sourceInformation;
       builder.graph.entry.addAtExit(localValue);
       return localValue;
     });
   }
 
   Local getTypeVariableAsLocal(TypeVariableType type) {
     return typeVariableLocals.putIfAbsent(type, () {
       return new TypeVariableLocal(type, executableContext);
@@ skipping 84 matching lines @@
     }
   }
 
   /// Create phis at the loop entry for local variables (ready for the values
   /// from the back edge).  Populate the phis with the current values.
   void beginLoopHeader(HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over it.
     Map<Local, HInstruction> savedDirectLocals =
         new Map<Local, HInstruction>.from(directLocals);
 
-    JavaScriptBackend backend = compiler.backend;
+    JavaScriptBackend backend = _compiler.backend;
     // Create phis for all elements in the definitions environment.
     savedDirectLocals.forEach((Local local, HInstruction instruction) {
       if (isAccessedDirectly(local)) {
         // We know 'this' cannot be modified.
         if (local != closureData.thisLocal) {
           HPhi phi =
               new HPhi.singleInput(local, instruction, backend.dynamicType);
           loopEntry.addPhi(phi);
           directLocals[local] = phi;
         } else {
@@ skipping 43 matching lines @@
   /// there is a conflict.
   /// If a phi node is necessary, it will use this handler's instruction as the
   /// first input, and the otherLocals instruction as the second.
   void mergeWith(LocalsHandler otherLocals, HBasicBlock joinBlock) {
     // If an element is in one map but not the other we can safely
     // ignore it. It means that a variable was declared in the
     // block. Since variable declarations are scoped the declared
     // variable cannot be alive outside the block. Note: this is only
     // true for nodes where we do joins.
     Map<Local, HInstruction> joinedLocals = new Map<Local, HInstruction>();
-    JavaScriptBackend backend = compiler.backend;
+    JavaScriptBackend backend = _compiler.backend;
     otherLocals.directLocals.forEach((Local local, HInstruction instruction) {
       // We know 'this' cannot be modified.
       if (local == closureData.thisLocal) {
         assert(directLocals[local] == instruction);
         joinedLocals[local] = instruction;
       } else {
         HInstruction mine = directLocals[local];
         if (mine == null) return;
         if (identical(instruction, mine)) {
           joinedLocals[local] = instruction;
@@ skipping 12 matching lines @@
   /// localsHandlers into a new one using phis.  The new localsHandler is
   /// returned.  Unless it is also in the list, the current localsHandler is not
   /// used for its values, only for its declared variables. This is a way to
   /// exclude local values from the result when they are no longer in scope.
   LocalsHandler mergeMultiple(
       List<LocalsHandler> localsHandlers, HBasicBlock joinBlock) {
     assert(localsHandlers.length > 0);
     if (localsHandlers.length == 1) return localsHandlers[0];
     Map<Local, HInstruction> joinedLocals = new Map<Local, HInstruction>();
     HInstruction thisValue = null;
-    JavaScriptBackend backend = compiler.backend;
+    JavaScriptBackend backend = _compiler.backend;
     directLocals.forEach((Local local, HInstruction instruction) {
       if (local != closureData.thisLocal) {
         HPhi phi = new HPhi.noInputs(local, backend.dynamicType);
         joinedLocals[local] = phi;
         joinBlock.addPhi(phi);
       } else {
         // We know that "this" never changes, if it's there.
         // Save it for later. While merging, there is no phi for "this",
         // so we don't have to special case it in the merge loop.
         thisValue = instruction;
@@ skipping 25 matching lines @@
     return this;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
       ThisLocal local = closureData.thisLocal;
       ClassElement cls = local.enclosingClass;
-      ClassWorld classWorld = compiler.world;
+      ClassWorld classWorld = _compiler.world;
       if (classWorld.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 TypeMask.nonNullSubtype(cls.declaration, compiler.world);
+        result = new TypeMask.nonNullSubtype(cls.declaration, _compiler.world);
       } else {
-        result = new TypeMask.nonNullSubclass(cls.declaration, compiler.world);
+        result = new TypeMask.nonNullSubclass(cls.declaration, _compiler.world);
       }
       cachedTypeOfThis = result;
     }
     return result;
   }
 
   Map<Element, TypeMask> cachedTypesOfCapturedVariables =
       new Map<Element, TypeMask>();
 
   TypeMask getTypeOfCapturedVariable(Element element) {
     assert(element.isField);
     return cachedTypesOfCapturedVariables.putIfAbsent(element, () {
-      return TypeMaskFactory.inferredTypeForElement(element, compiler);
+      return TypeMaskFactory.inferredTypeForElement(element, _compiler);
     });
   }
 
   /// Variables stored in the current activation. These variables are
   /// being updated in try/catch blocks, and should be
   /// accessed indirectly through [HLocalGet] and [HLocalSet].
   Map<Local, HLocalValue> activationVariables = <Local, HLocalValue>{};
 }