Fix the local variable lookup in the locals handler.

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 JBoxedField, JClosureField;
 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 273 matching lines @@
     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];
     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 18 matching lines @@
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(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.
-      HInstruction box = readLocal(redirect.box);
+      if (redirect is BoxFieldElement) {
+        localBox = redirect.box;
+      } else if (redirect is JBoxedField) {
+        localBox = redirect.box;
+      }
+      assert(localBox != null);
+
+      HInstruction box = readLocal(localBox);
       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);
       builder.add(instruction);
@@ skipping 38 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 JBoxedField) {
+        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)';
 }