Add J-elements

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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 dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 11 matching lines @@
 import '../elements/entities.dart';
 import '../elements/names.dart';
 import '../elements/types.dart';
 import '../environment.dart';
 import '../frontend_strategy.dart';
 import '../js_backend/backend_usage.dart';
 import '../js_backend/constant_system_javascript.dart';
 import '../js_backend/interceptor_data.dart';
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
+import '../js_model/elements.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../ssa/kernel_impact.dart';
 import '../universe/class_set.dart';
 import '../universe/function_set.dart';
 import '../universe/selector.dart';
 import '../universe/world_builder.dart';
 import '../world.dart';
 import '../util/util.dart' show Link, LinkBuilder;
@@ skipping 445 matching lines @@
                   _getTypeVariable(node.typeParameters[index]));
             }));
         env.rawType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .filled(
                 node.typeParameters.length, const DynamicType()));
       }
     }
   }
 
-  InterfaceType getThisType(KClass cls) {
+  InterfaceType _getThisType(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.thisType;
   }
 
   InterfaceType _getRawType(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureThisAndRawType(cls, env);
     return env.rawType;
   }
@@ skipping 61 matching lines @@
   }
 
   ClassEntity _getAppliedMixin(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.mixedInType?.element;
   }
 
   DartType _substByContext(DartType type, InterfaceType context) {
     return type.subst(
-        context.typeArguments, getThisType(context.element).typeArguments);
+        context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
   InterfaceType _getSuperType(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
     _ensureSupertypes(cls, env);
     return env.supertype;
   }
 
   bool _isMixinApplication(KClass cls) {
     _KClassEnv env = _classEnvs[cls.classIndex];
@@ skipping 145 matching lines @@
 
   ResolutionImpact computeWorldImpact(KMember member) {
     return _memberList[member.memberIndex].getWorldImpact(this);
   }
 
   @override
   Spannable getSpannable(MemberEntity member, ir.Node node) {
     return member;
   }
 
-  /// Returns the kernel IR node that defines the [member].
+  @override
   ir.Member getMemberNode(KMember member) {
     return _memberList[member.memberIndex].node;
   }
 
   /// Returns the kernel IR node that defines the [cls].
   ir.Class getClassNode(KClass cls) {
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
@@ skipping 375 matching lines @@
   @override
   Iterable<LibraryEntity> get libraries => elementMap._libraries;
 
   @override
   String getLibraryName(LibraryEntity library) {
     return elementMap._getLibraryName(library);
   }
 
   @override
   InterfaceType getThisType(ClassEntity cls) {
-    return elementMap.getThisType(cls);
+    return elementMap._getThisType(cls);
   }
 
   @override
   InterfaceType getRawType(ClassEntity cls) {
     return elementMap._getRawType(cls);
   }
 
   @override
   bool isGenericClass(ClassEntity cls) {
     return getThisType(cls).typeArguments.isNotEmpty;
@@ skipping 546 matching lines @@
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(johnniwinther): Compute this.
     return false;
   }
 }
+
+class JsKernelToElementMap extends KernelToElementMapMixin {
+  final JsToFrontendMap _map;
+  final ElementEnvironment _elementEnvironment;
+  final CommonElements _commonElements;
+  final KernelToElementMapImpl _elementMap;
+
+  JsKernelToElementMap(this._map, this._elementEnvironment,
+      this._commonElements, this._elementMap);
+
+  @override
+  Spannable getSpannable(MemberEntity member, ir.Node node) {
+    return _elementMap.getSpannable(_map.toFrontendMember(member), node);
+  }
+
+  @override
+  LibraryEntity getLibrary(ir.Library node) {
+    return _map.toBackendLibrary(_elementMap.getLibrary(node));
+  }
+
+  @override
+  Local getLocalFunction(ir.TreeNode node) {
+    throw new UnsupportedError("JsKernelToElementMap.getLocalFunction");
+  }
+
+  @override
+  ClassEntity getClass(ir.Class node) {
+    return _map.toBackendClass(_elementMap.getClass(node));
+  }
+
+  @override
+  FieldEntity getField(ir.Field node) {
+    return _map.toBackendMember(_elementMap.getField(node));
+  }
+
+  @override
+  MemberEntity getSuperMember(ir.Member context, ir.Name name, ir.Member target,
+      {bool setter: false}) {
+    return _map.toBackendMember(
+        _elementMap.getSuperMember(context, name, target, setter: setter));
+  }
+
+  @override
+  FunctionEntity getMethod(ir.Procedure node) {
+    return _map.toBackendMember(_elementMap.getMethod(node));
+  }
+
+  @override
+  ir.Member getMemberNode(MemberEntity member) {
+    return _elementMap.getMemberNode(_map.toFrontendMember(member));
+  }
+
+  @override
+  MemberEntity getMember(ir.Member node) {
+    return _map.toBackendMember(_elementMap.getMember(node));
+  }
+
+  @override
+  ConstructorEntity getSuperConstructor(
+      ir.Constructor constructor, ir.Member target) {
+    return _map
+        .toBackendMember(_elementMap.getSuperConstructor(constructor, target));
+  }
+
+  @override
+  ConstructorEntity getConstructor(ir.Member node) {
+    return _map.toBackendMember(_elementMap.getConstructor(node));
+  }
+
+  @override
+  InterfaceType createInterfaceType(
+      ir.Class cls, List<ir.DartType> typeArguments) {
+    return _map
+        .toBackendType(_elementMap.createInterfaceType(cls, typeArguments));
+  }
+
+  @override
+  InterfaceType getInterfaceType(ir.InterfaceType type) {
+    return _map.toBackendType(_elementMap.getInterfaceType(type));
+  }
+
+  @override
+  List<DartType> getDartTypes(List<ir.DartType> types) {
+    return _elementMap.getDartTypes(types).map(_map.toBackendType).toList();
+  }
+
+  @override
+  FunctionType getFunctionType(ir.FunctionNode node) {
+    return _map.toBackendType(_elementMap.getFunctionType(node));
+  }
+
+  @override
+  DartType getDartType(ir.DartType type) {
+    return _map.toBackendType(_elementMap.getDartType(type));
+  }
+
+  @override
+  ElementEnvironment get elementEnvironment {
+    return _elementEnvironment;
+  }
+
+  @override
+  CommonElements get commonElements {
+    return _commonElements;
+  }
+
+  @override
+  ConstantValue computeConstantValue(ConstantExpression constant,
+      {bool requireConstant: true}) {
+    throw new UnsupportedError("JsKernelToElementMap.computeConstantValue");
+  }
+
+  @override
+  native.BehaviorBuilder get nativeBehaviorBuilder {
+    throw new UnsupportedError("JsKernelToElementMap.nativeBehaviorBuilder");
+  }
+
+  @override
+  DiagnosticReporter get reporter {
+    return _elementMap.reporter;
+  }
+
+  @override
+  ConstantValue getFieldConstantValue(ir.Field field) {
+    throw new UnsupportedError("JsKernelToElementMap.getFieldConstantValue");
+  }
+}