Fix the locals lookup of variables and partial implementation of boxing of variables.

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 '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../io/source_information.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/interceptor_data.dart';
+import '../js_model/closure.dart' show JClosureField, JRecord;
 import '../tree/tree.dart' as ast;
 import '../types/types.dart';
 import '../world.dart' show ClosedWorld;
 
 import 'graph_builder.dart';
 import 'nodes.dart';
 import 'types.dart';
 
 /// Keeps track of locals (including parameters and phis) when building. The
 /// 'this' reference is treated as parameter and hence handled by this class,
@@ skipping 124 matching lines @@
       // The box is passed as a parameter to a generative
       // constructor body.
       box = builder.addParameter(closureInfo.context, commonMasks.nonNullType);
     } else {
       box = createBox();
     }
     // Add the box to the known locals.
     directLocals[closureInfo.context] = 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.
-    closureInfo.forEachBoxedVariable((_from, _to) {
-      LocalVariableElement from = _from;
-      BoxFieldElement to = _to;
+    closureInfo.forEachBoxedVariable((Local from, FieldEntity boxTo) {
       // The [from] can only be a parameter for function-scopes and not
       // loop scopes.
       if (from.isRegularParameter && !forGenerativeConstructorBody) {
         // Now that the redirection is set up, the update to the local will
         // write the parameter value into the box.
         // Store the captured parameter in the box. Get the current value
         // before we put the redirection in place.
         // We don't need to update the local for a generative
         // constructor body, because it receives a box that already
         // contains the updates as the last parameter.
         HInstruction instruction = readLocal(from);
-        redirectElement(from, to);
+        redirectElement(from, boxTo);
         updateLocal(from, instruction);
       } else {
-        redirectElement(from, to);
+        redirectElement(from, boxTo);
       }
     });
   }
 
   /// Replaces the current box with a new box and copies over the given list
   /// of elements from the old box into the new box.
   void updateCaptureBox(Local currentBox, List<Local> toBeCopiedElements) {
     // Create a new box and copy over the values from the old box into the
     // new one.
     HInstruction oldBox = readLocal(currentBox);
@@ skipping 110 matching lines @@
     assert(local != null);
     return !redirectionMapping.containsKey(local) &&
         !scopeInfo.localIsUsedInTryOrSync(local);
   }
 
   bool isStoredInClosureField(Local local) {
     assert(local != null);
     if (isAccessedDirectly(local)) return false;
     if (scopeInfo is! ClosureRepresentationInfo) return false;
     FieldEntity redirectTarget = redirectionMapping[local];
+    print(
+        'is stored in closure field $local ${isAccessedDirectly(local)} ${scopeInfo.runtimeType} ${redirectTarget.runtimeType}');
     if (redirectTarget == null) return false;
-    return redirectTarget is ClosureFieldElement;
+    return redirectTarget is ClosureFieldElement ||
+        redirectTarget is JClosureField;
   }
 
   bool isBoxed(Local local) {
     if (isAccessedDirectly(local)) return false;
     if (isStoredInClosureField(local)) return false;
     return redirectionMapping.containsKey(local);
   }
 
   bool _isUsedInTryOrGenerator(Local local) {
     return scopeInfo.localIsUsedInTryOrSync(local);
@@ skipping 17 matching lines @@
               "$executableContext.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
+      print('bbbbbbb $local');
       ClosureRepresentationInfo closureData = scopeInfo;
-      ClosureFieldElement redirect = redirectionMapping[local];
+      FieldEntity redirect = redirectionMapping[local];
       HInstruction receiver = readLocal(closureData.closureEntity);
       TypeMask type = local is BoxLocal
           ? commonMasks.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];
+      FieldEntity redirect = redirectionMapping[local];
+      BoxLocal localBox;
       // 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.
+      print("AAAAAAAAAAAAAA $local $redirect ${redirect.runtimeType}");
+      if (redirect is BoxFieldElement) {
+        localBox = redirect.box;
+      } else if (redirect is JRecord) {
+        localBox = redirect.box;
+      }
+      assert(localBox != null);
+
       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, commonMasks.dynamicType, sourceInformation);
@@ skipping 39 matching lines @@
   void updateLocal(Local local, HInstruction value,
       {SourceInformation sourceInformation}) {
     if (value is HRef) {
       HRef ref = value;
       value = ref.value;
     }
     assert(!isStoredInClosureField(local));
     if (isAccessedDirectly(local)) {
       directLocals[local] = value;
     } else if (isBoxed(local)) {
-      BoxFieldElement redirect = redirectionMapping[local];
+      FieldEntity redirect = redirectionMapping[local];
+      assert(redirect != null);
+      BoxLocal localBox;
+      if (redirect is BoxFieldElement) {
+        localBox = redirect.box;
+      } else if (redirect is JRecord) {
+        localBox = redirect.box;
+      }
+      assert(localBox != null);
+
       // 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.
-      HInstruction box = readLocal(redirect.box);
+      HInstruction box = readLocal(localBox);
       builder.add(new HFieldSet(redirect, box, value)
         ..sourceInformation = sourceInformation);
     } else {
       assert(_isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       builder.add(new HLocalSet(local, localValue, value)
         ..sourceInformation = sourceInformation);
     }
   }
 
@@ skipping 201 matching lines @@
         // simplicity, we mark the type as an interface type.
         result = new TypeMask.nonNullSubtype(cls, closedWorld);
       } else {
         result = new TypeMask.nonNullSubclass(cls, closedWorld);
       }
       cachedTypeOfThis = result;
     }
     return result;
   }
 
-  Map<Element, TypeMask> cachedTypesOfCapturedVariables =
-      new Map<Element, TypeMask>();
+  Map<FieldEntity, TypeMask> cachedTypesOfCapturedVariables =
+      new Map<FieldEntity, TypeMask>();
 
-  TypeMask getTypeOfCapturedVariable(FieldElement element) {
+  TypeMask getTypeOfCapturedVariable(FieldEntity element) {
     return cachedTypesOfCapturedVariables.putIfAbsent(element, () {
       return TypeMaskFactory.inferredTypeForMember(
           element, _globalInferenceResults);
     });
   }
 
   /// 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>{};
@@ skipping 13 matching lines @@
   final MemberEntity memberContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext, this.memberContext);
 
   toString() => 'SyntheticLocal($name)';
 }