Type .targetElement as MemberEntity

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/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../io/source_information.dart';
@@ skipping 18 matching lines @@
   /// iteration order a function only of insertions and not a function of
   /// e.g. Element hash codes.  I'd prefer to use a SortedMap but some elements
   /// don't have source locations for [Elements.compareByPosition].
   Map<Local, HInstruction> directLocals = new Map<Local, HInstruction>();
   Map<Local, CapturedVariable> redirectionMapping =
       new Map<Local, CapturedVariable>();
   final GraphBuilder builder;
   ClosureClassMap closureData;
   Map<ResolutionTypeVariableType, TypeVariableLocal> typeVariableLocals =
       new Map<ResolutionTypeVariableType, TypeVariableLocal>();
-  final ExecutableElement executableContext;
+  final Entity executableContext;
+  final MemberEntity memberContext;
 
   /// The class that defines the current type environment or null if no type
   /// variables are in scope.
-  ClassElement get contextClass => executableContext.contextClass;
+  final ClassElement contextClass;
 
   /// The type of the current instance, if concrete.
   ///
   /// This allows for handling fixed type argument in case of inlining. For
   /// instance, checking `'foo'` against `String` instead of `T` in `main`:
   ///
   ///     class Foo<T> {
   ///       T field;
   ///       Foo(this.field);
   ///     }
   ///     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 ResolutionInterfaceType instanceType;
 
   final NativeData _nativeData;
 
   final InterceptorData _interceptorData;
 
   LocalsHandler(
       this.builder,
       this.executableContext,
+      this.memberContext,
+      this.contextClass,
       ResolutionInterfaceType instanceType,
       this._nativeData,
       this._interceptorData)
       : this.instanceType =
             instanceType == null || instanceType.containsTypeVariables
                 ? null
                 : instanceType;
 
   ClosedWorld get closedWorld => builder.closedWorld;
 
@@ skipping 19 matching lines @@
     return type;
   }
 
   /// 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,
+        memberContext = other.memberContext,
+        contextClass = other.contextClass,
         instanceType = other.instanceType,
         builder = other.builder,
         closureData = other.closureData,
         _nativeData = other._nativeData,
         _interceptorData = other._interceptorData,
         activationVariables = other.activationVariables,
         cachedTypeOfThis = other.cachedTypeOfThis,
         cachedTypesOfCapturedVariables = other.cachedTypesOfCapturedVariables;
 
   /// Redirects accesses from element [from] to element [to]. The [to] element
@@ skipping 133 matching lines @@
     // When the class extends a native class, the instance is pre-constructed
     // and passed to the generative constructor factory function as a parameter.
     // Instead of allocating and initializing the object, the constructor
     // 'upgrades' the native subclass object by initializing the Dart fields.
     bool isNativeUpgradeFactory = element.isGenerativeConstructor &&
         _nativeData.isNativeOrExtendsNative(cls);
     if (_interceptorData.isInterceptedMethod(element)) {
       bool isInterceptedClass =
           _interceptorData.isInterceptedClass(cls.declaration);
       String name = isInterceptedClass ? 'receiver' : '_';
-      SyntheticLocal parameter = new SyntheticLocal(name, executableContext);
+      SyntheticLocal parameter = createLocal(name);
       HParameterValue value = new HParameterValue(parameter, getTypeOfThis());
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAfter(directLocals[closureData.thisLocal], value);
       if (builder.lastAddedParameter == null) {
         // If this is the first parameter inserted, make sure it stays first.
         builder.lastAddedParameter = value;
       }
       if (isInterceptedClass) {
         // Only use the extra parameter in intercepted classes.
         directLocals[closureData.thisLocal] = value;
       }
     } else if (isNativeUpgradeFactory) {
-      SyntheticLocal parameter =
-          new SyntheticLocal('receiver', executableContext);
+      SyntheticLocal parameter = createLocal('receiver');
       // Unlike `this`, receiver is nullable since direct calls to generative
       // constructor call the constructor with `null`.
       HParameterValue value =
           new HParameterValue(parameter, new TypeMask.exact(cls, closedWorld));
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAtEntry(value);
       if (builder.lastAddedParameter == null) {
         // If this is the first parameter inserted, make sure it stays first.
         builder.lastAddedParameter = value;
       }
@@ skipping 364 matching lines @@
     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>{};
+
+  SyntheticLocal createLocal(String name) {
+    return new SyntheticLocal(name, executableContext, memberContext);
+  }
 }
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
 class SyntheticLocal extends Local {
   final String name;
-  final ExecutableElement executableContext;
+  final Entity executableContext;
+  final MemberEntity memberContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
-  SyntheticLocal(this.name, this.executableContext);
-
-  @override
-  MemberElement get memberContext => executableContext.memberContext;
+  SyntheticLocal(this.name, this.executableContext, this.memberContext);
 
   toString() => 'SyntheticLocal($name)';
 }