Implement .getCallType

pkg/compiler/lib/src/js_backend/namer.dart

 // Copyright (c) 2011, 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.
 
 library js_backend.namer;
 
 import 'dart:collection' show HashMap;
 
 import 'package:js_runtime/shared/embedded_names.dart' show JsGetName;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Selectors;
 import '../constants/values.dart';
-import '../common_elements.dart' show CommonElements;
+import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../diagnostics/invariant.dart' show DEBUG_MODE;
 import '../elements/elements.dart'
     show
         ClassElement,
         Element,
         Elements,
         MemberElement,
         MixinApplicationElement;
 import '../elements/entities.dart';
 import '../elements/entity_utils.dart' as utils;
@@ skipping 545 matching lines @@
   final Map<LibraryEntity, String> _libraryKeys =
       new HashMap<LibraryEntity, String>();
 
   Namer(this._closedWorld, this._codegenWorldBuilder) {
     _literalAsyncPrefix = new StringBackedName(asyncPrefix);
     _literalGetterPrefix = new StringBackedName(getterPrefix);
     _literalSetterPrefix = new StringBackedName(setterPrefix);
     _literalLazyGetterPrefix = new StringBackedName(lazyGetterPrefix);
   }
 
+  ElementEnvironment get _elementEnvironment => _closedWorld.elementEnvironment;
+
   CommonElements get _commonElements => _closedWorld.commonElements;
 
   NativeData get _nativeData => _closedWorld.nativeData;
 
   String get deferredTypesName => 'deferredTypes';
   String get isolateName => 'Isolate';
   String get isolatePropertiesName => r'$isolateProperties';
   jsAst.Name get noSuchMethodName => invocationName(Selectors.noSuchMethod_);
 
   /**
@@ skipping 355 matching lines @@
       return _disambiguateInternalMember(element, proposeName);
     }
 
     // No superclass uses the disambiguated name as a property name, so we can
     // use it for this field. This generates nicer field names since otherwise
     // the field name would have to be mangled.
     return _disambiguateMember(new Name(element.name, element.library));
   }
 
   bool _isShadowingSuperField(FieldEntity element) {
-    ClassEntity cls = element.enclosingClass;
-    if (cls is ClassElement) {
-      return cls.hasFieldShadowedBy(element);
+    assert(element.isField);
+    String fieldName = element.name;
+    bool isPrivate = Name.isPrivateName(fieldName);
+    LibraryEntity memberLibrary = element.library;
+    ClassEntity lookupClass =
+        _elementEnvironment.getSuperClass(element.enclosingClass);
+    while (lookupClass != null) {
+      MemberEntity foundMember =
+          _elementEnvironment.lookupClassMember(lookupClass, fieldName);
+      if (foundMember != null) {
+        if (foundMember.isField) {
+          if (!isPrivate || memberLibrary == foundMember.library) {
+            // Private fields can only be shadowed by a field declared in the
+            // same library.
+            return true;
+          }
+        }
+      }
+      lookupClass = _elementEnvironment.getSuperClass(lookupClass);
     }
-    // TODO(redemption): Support class entities.
     return false;
   }
 
   /// True if [class_] is a non-native class that inherits from a native class.
   bool _isUserClassExtendingNative(ClassEntity class_) {
     return !_nativeData.isNativeClass(class_) &&
         _nativeData.isNativeOrExtendsNative(class_);
   }
 
   /// Annotated name for the setter of [element].
@@ skipping 1273 matching lines @@
   void addSuggestion(String original, String suggestion) {
     assert(!_suggestedNames.containsKey(original));
     _suggestedNames[original] = suggestion;
   }
 
   bool hasSuggestion(String original) => _suggestedNames.containsKey(original);
   bool isSuggestion(String candidate) {
     return _suggestedNames.containsValue(candidate);
   }
 }