Extract reusable parts of KernelAstAdapter in a mixin.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
+import '../core_types.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart';
 import '../js_backend/js_backend.dart';
 import '../kernel/element_adapter.dart';
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/tree.dart' as ast;
 import '../types/masks.dart';
 import '../types/types.dart';
 import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart' show SwitchCaseJumpHandler;
 import 'locals_handler.dart';
 import 'types.dart';
 
 /// A helper class that abstracts all accesses of the AST from Kernel nodes.
 ///
 /// The goal is to remove all need for the AST from the Kernel SSA builder.
-class KernelAstAdapter implements KernelElementAdapter {
+class KernelAstAdapter extends KernelElementAdapterMixin {
   final Kernel kernel;
   final JavaScriptBackend _backend;
   final Map<ir.Node, ast.Node> _nodeToAst;
   final Map<ir.Node, Element> _nodeToElement;
   final Map<ir.VariableDeclaration, SyntheticLocal> _syntheticLocals =
       <ir.VariableDeclaration, SyntheticLocal>{};
   // TODO(efortuna): In an ideal world the TreeNodes should be some common
   // interface we create for both ir.Statements and ir.SwitchCase (the
   // ContinueSwitchStatement's target is a SwitchCase) rather than general
   // TreeNode. Talking to Asger about this.
@@ skipping 25 matching lines @@
     }
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     for (TypeVariableElement typeVariable in kernel.typeParameters.keys) {
       _nodeToElement[kernel.typeParameters[typeVariable]] = typeVariable;
     }
     _typeConverter = new DartTypeConverter(this);
   }
 
+  CommonElements get commonElements => _compiler.commonElements;
+
   /// Push the existing resolved AST on the stack and shift the current resolved
   /// AST to the AST that this kernel node points to.
   void pushResolvedAst(ir.Node node) {
     _resolvedAstStack.add(_resolvedAst);
     _resolvedAst = (getElement(node) as AstElement).resolvedAst;
   }
 
   /// Pop the resolved AST stack to reset it to the previous resolved AST node.
   void popResolvedAstStack() {
     assert(_resolvedAstStack.isNotEmpty);
@@ skipping 38 matching lines @@
   MemberElement getMember(ir.Member node) => getElement(node).declaration;
 
   MethodElement getMethod(ir.Procedure node) => getElement(node).declaration;
 
   FieldElement getField(ir.Field node) => getElement(node).declaration;
 
   ClassElement getClass(ir.Class node) => getElement(node).declaration;
 
   LibraryElement getLibrary(ir.Library node) => getElement(node).declaration;
 
-  LocalFunctionElement getLocalFunction(ir.Node node) => getElement(node);
+  LocalFunctionElement getLocalFunction(ir.TreeNode node) => getElement(node);
 
   ast.Node getNode(ir.Node node) {
     ast.Node result = _nodeToAst[node];
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, result != null,
         message: "No node found for $node"));
     return result;
   }
 
   ast.Node getNodeOrNull(ir.Node node) {
     return _nodeToAst[node];
@@ skipping 21 matching lines @@
 
   TypeMask returnTypeOf(ir.Member node) {
     return TypeMaskFactory.inferredReturnTypeForElement(
         getElement(node), _globalInferenceResults);
   }
 
   SideEffects getSideEffects(ir.Node node, ClosedWorld closedWorld) {
     return closedWorld.getSideEffectsOfElement(getElement(node));
   }
 
-  CallStructure getCallStructure(ir.Arguments arguments) {
-    int argumentCount = arguments.positional.length + arguments.named.length;
-    List<String> namedArguments = arguments.named.map((e) => e.name).toList();
-    return new CallStructure(argumentCount, namedArguments);
-  }
-
   FunctionSignature getFunctionSignature(ir.FunctionNode function) {
     return getElement(function).asFunctionElement().functionSignature;
   }
 
-  Name getName(ir.Name name) {
-    return new Name(
-        name.name, name.isPrivate ? getLibrary(name.library) : null);
-  }
-
   ir.Field getFieldFromElement(FieldElement field) {
     return kernel.fields[field];
   }
 
-  Selector getSelector(ir.Expression node) {
-    if (node is ir.PropertyGet) return getGetterSelector(node);
-    if (node is ir.PropertySet) return getSetterSelector(node);
-    if (node is ir.InvocationExpression) return getInvocationSelector(node);
-    _compiler.reporter.internalError(getNode(node),
-        "Can only get the selector for a property get or an invocation.");
-    return null;
-  }
-
-  Selector getInvocationSelector(ir.InvocationExpression invocation) {
-    Name name = getName(invocation.name);
-    SelectorKind kind;
-    if (Elements.isOperatorName(invocation.name.name)) {
-      if (name == Names.INDEX_NAME || name == Names.INDEX_SET_NAME) {
-        kind = SelectorKind.INDEX;
-      } else {
-        kind = SelectorKind.OPERATOR;
-      }
-    } else {
-      kind = SelectorKind.CALL;
-    }
-
-    CallStructure callStructure = getCallStructure(invocation.arguments);
-    return new Selector(kind, name, callStructure);
-  }
-
-  Selector getGetterSelector(ir.PropertyGet getter) {
-    ir.Name irName = getter.name;
-    Name name = new Name(
-        irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
-    return new Selector.getter(name);
-  }
-
-  Selector getSetterSelector(ir.PropertySet setter) {
-    ir.Name irName = setter.name;
-    Name name = new Name(
-        irName.name, irName.isPrivate ? getLibrary(irName.library) : null);
-    return new Selector.setter(name);
-  }
-
   TypeMask typeOfInvocation(ir.MethodInvocation send, ClosedWorld closedWorld) {
     ast.Node operatorNode = kernel.nodeToAstOperator[send];
     if (operatorNode != null) {
       return _resultOf(_target).typeOfOperator(operatorNode);
     }
     if (send.name.name == '[]=') {
       return closedWorld.commonMasks.dynamicType;
     }
     return _resultOf(_target).typeOfSend(getNode(send));
   }
@@ skipping 363 matching lines @@
       ConstantExpression constant = node.accept(new Constantifier(this));
       if (constant == null) {
         throw new UnsupportedError(
             'No constant for ${DebugPrinter.prettyPrint(node)}');
       }
       metadata.add(constant);
     });
     return metadata;
   }
 
-  /// Compute the kind of foreign helper function called by [node], if any.
-  ForeignKind getForeignKind(ir.StaticInvocation node) {
-    if (isForeignLibrary(node.target.enclosingLibrary)) {
-      switch (node.target.name.name) {
-        case BackendHelpers.JS:
-          return ForeignKind.JS;
-        case BackendHelpers.JS_BUILTIN:
-          return ForeignKind.JS_BUILTIN;
-        case BackendHelpers.JS_EMBEDDED_GLOBAL:
-          return ForeignKind.JS_EMBEDDED_GLOBAL;
-        case BackendHelpers.JS_INTERCEPTOR_CONSTANT:
-          return ForeignKind.JS_INTERCEPTOR_CONSTANT;
-      }
-    }
-    return ForeignKind.NONE;
+  @override
+  LibraryEntity lookupLibrary(Uri uri) {
+    return _compiler.libraryLoader.lookupLibrary(uri);
   }
 
-  /// Return `true` if [node] is the `dart:_foreign_helper` library.
-  bool isForeignLibrary(ir.Library node) {
-    return node.importUri == BackendHelpers.DART_FOREIGN_HELPER;
-  }
-
-  /// Looks up [typeName] for use in the spec-string of a `JS` called.
-  // TODO(johnniwinther): Use this in [native.NativeBehavior] instead of calling
-  // the `ForeignResolver`.
-  // TODO(johnniwinther): Cache the result to avoid redundant lookups?
-  native.TypeLookup _typeLookup({bool resolveAsRaw: true}) {
-    return (String typeName) {
-      ResolutionDartType findIn(Uri uri) {
-        LibraryElement library = _compiler.libraryLoader.lookupLibrary(uri);
-        if (library != null) {
-          Element element = library.find(typeName);
-          if (element != null && element.isClass) {
-            ClassElement cls = element;
-            // TODO(johnniwinther): Align semantics.
-            return resolveAsRaw ? cls.rawType : cls.thisType;
-          }
-        }
-        return null;
-      }
-
-      ResolutionDartType type = findIn(Uris.dart_core);
-      type ??= findIn(BackendHelpers.DART_JS_HELPER);
-      type ??= findIn(BackendHelpers.DART_INTERCEPTORS);
-      type ??= findIn(BackendHelpers.DART_ISOLATE_HELPER);
-      type ??= findIn(Uris.dart_collection);
-      type ??= findIn(Uris.dart_html);
-      type ??= findIn(Uris.dart_svg);
-      type ??= findIn(Uris.dart_web_audio);
-      type ??= findIn(Uris.dart_web_gl);
-      return type;
-    };
-  }
-
-  String _getStringArgument(ir.StaticInvocation node, int index) {
-    return node.arguments.positional[index].accept(new Stringifier());
-  }
-
-  /// Computes the [native.NativeBehavior] for a call to the [JS] function.
-  // TODO(johnniwinther): Cache this for later use.
-  native.NativeBehavior getNativeBehaviorForJsCall(ir.StaticInvocation node) {
-    if (node.arguments.positional.length < 2 ||
-        node.arguments.named.isNotEmpty) {
-      reporter.reportErrorMessage(
-          CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS);
-      return new native.NativeBehavior();
-    }
-    String specString = _getStringArgument(node, 0);
-    if (specString == null) {
-      reporter.reportErrorMessage(
-          CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_FIRST);
-      return new native.NativeBehavior();
-    }
-
-    String codeString = _getStringArgument(node, 1);
-    if (codeString == null) {
-      reporter.reportErrorMessage(
-          CURRENT_ELEMENT_SPANNABLE, MessageKind.WRONG_ARGUMENT_FOR_JS_SECOND);
-      return new native.NativeBehavior();
-    }
-
-    return native.NativeBehavior.ofJsCall(
-        specString,
-        codeString,
-        _typeLookup(resolveAsRaw: true),
-        CURRENT_ELEMENT_SPANNABLE,
-        reporter,
-        _compiler.commonElements);
-  }
-
-  /// Computes the [native.NativeBehavior] for a call to the [JS_BUILTIN]
-  /// function.
-  // TODO(johnniwinther): Cache this for later use.
-  native.NativeBehavior getNativeBehaviorForJsBuiltinCall(
-      ir.StaticInvocation node) {
-    if (node.arguments.positional.length < 1) {
-      reporter.internalError(
-          CURRENT_ELEMENT_SPANNABLE, "JS builtin expression has no type.");
-      return new native.NativeBehavior();
-    }
-    if (node.arguments.positional.length < 2) {
-      reporter.internalError(
-          CURRENT_ELEMENT_SPANNABLE, "JS builtin is missing name.");
-      return new native.NativeBehavior();
-    }
-    String specString = _getStringArgument(node, 0);
-    if (specString == null) {
-      reporter.internalError(
-          CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
-      return new native.NativeBehavior();
-    }
-    return native.NativeBehavior.ofJsBuiltinCall(
-        specString,
-        _typeLookup(resolveAsRaw: true),
-        CURRENT_ELEMENT_SPANNABLE,
-        reporter,
-        _compiler.commonElements);
-  }
-
-  /// Computes the [native.NativeBehavior] for a call to the
-  /// [JS_EMBEDDED_GLOBAL] function.
-  // TODO(johnniwinther): Cache this for later use.
-  native.NativeBehavior getNativeBehaviorForJsEmbeddedGlobalCall(
-      ir.StaticInvocation node) {
-    if (node.arguments.positional.length < 1) {
-      reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
-          "JS embedded global expression has no type.");
-      return new native.NativeBehavior();
-    }
-    if (node.arguments.positional.length < 2) {
-      reporter.internalError(
-          CURRENT_ELEMENT_SPANNABLE, "JS embedded global is missing name.");
-      return new native.NativeBehavior();
-    }
-    if (node.arguments.positional.length > 2 ||
-        node.arguments.named.isNotEmpty) {
-      reporter.internalError(CURRENT_ELEMENT_SPANNABLE,
-          "JS embedded global has more than 2 arguments.");
-      return new native.NativeBehavior();
-    }
-    String specString = _getStringArgument(node, 0);
-    if (specString == null) {
-      reporter.internalError(
-          CURRENT_ELEMENT_SPANNABLE, "Unexpected first argument.");
-      return new native.NativeBehavior();
-    }
-    return native.NativeBehavior.ofJsEmbeddedGlobalCall(
-        specString,
-        _typeLookup(resolveAsRaw: true),
-        CURRENT_ELEMENT_SPANNABLE,
-        reporter,
-        _compiler.commonElements);
-  }
-
-  /// Computes the [InterfaceType] referenced by a call to the
-  /// [JS_INTERCEPTOR_CONSTANT] function, if any.
-  InterfaceType getInterfaceTypeForJsInterceptorCall(ir.StaticInvocation node) {
-    if (node.arguments.positional.length != 1 ||
-        node.arguments.named.isNotEmpty) {
-      reporter.reportErrorMessage(CURRENT_ELEMENT_SPANNABLE,
-          MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
-    }
-    ir.Node argument = node.arguments.positional.first;
-    if (argument is ir.TypeLiteral && argument.type is ir.InterfaceType) {
-      return getInterfaceType(argument.type);
+  @override
+  ClassElement lookupClass(LibraryElement library, String name) {
+    Element element = library.find(name);
+    if (element != null && element.isClass) {
+      return element;
     }
     return null;
   }
 
-  /// Returns `true` is [node] has a `@Native(...)` annotation.
-  // TODO(johnniwinther): Cache this for later use.
-  bool isNativeClass(ir.Class node) {
-    for (ir.Expression annotation in node.annotations) {
-      if (annotation is ir.ConstructorInvocation) {
-        ConstructorElement target = getElement(annotation.target).declaration;
-        if (target.enclosingClass ==
-            _compiler.commonElements.nativeAnnotationClass) {
-          return true;
-        }
-      }
-    }
-    return false;
+  @override
+  InterfaceType getRawType(ClassElement cls) {
+    return cls.rawType;
+  }
+
+  @override
+  InterfaceType getThisType(ClassElement cls) {
+    return cls.thisType;
   }
 
   /// Computes the native behavior for reading the native [field].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field) {
     ResolutionDartType type = getDartType(field.type);
     List<ConstantExpression> metadata = getMetadata(field.annotations);
     return native.NativeBehavior.ofFieldLoad(CURRENT_ELEMENT_SPANNABLE, type,
-        metadata, _typeLookup(resolveAsRaw: false), _compiler,
+        metadata, typeLookup(resolveAsRaw: false), _compiler,
         isJsInterop: false);
   }
 
   /// Computes the native behavior for writing to the native [field].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
     ResolutionDartType type = getDartType(field.type);
     return native.NativeBehavior.ofFieldStore(type, _compiler.resolution);
   }
 
   /// Computes the native behavior for calling [procedure].
   // TODO(johnniwinther): Cache this for later use.
   native.NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure) {
     ResolutionDartType type = getFunctionType(procedure.function);
     List<ConstantExpression> metadata = getMetadata(procedure.annotations);
     return native.NativeBehavior.ofMethod(CURRENT_ELEMENT_SPANNABLE, type,
-        metadata, _typeLookup(resolveAsRaw: false), _compiler,
+        metadata, typeLookup(resolveAsRaw: false), _compiler,
         isJsInterop: false);
   }
 
   MemberEntity getConstructorBodyEntity(ir.Constructor constructor) {
     AstElement element = getElement(constructor);
     MemberEntity constructorBody =
         ConstructorBodyElementX.createFromResolvedAst(element.resolvedAst);
     assert(constructorBody != null);
     return constructorBody;
   }
@@ skipping 54 matching lines @@
             .toList()),
         visitTypes(node.positionalParameters
             .skip(node.requiredParameterCount)
             .toList()),
         node.namedParameters.map((n) => n.name).toList(),
         node.namedParameters.map((n) => visitType(n.type)).toList());
   }
 
   @override
   ResolutionDartType visitInterfaceType(ir.InterfaceType node) {
-    ClassElement cls = astAdapter.getElement(node.classNode);
+    ClassElement cls = astAdapter.getClass(node.classNode);
     return new ResolutionInterfaceType(cls, visitTypes(node.typeArguments));
   }
 
   @override
   ResolutionDartType visitVoidType(ir.VoidType node) {
     return const ResolutionVoidType();
   }
 
   @override
   ResolutionDartType visitDynamicType(ir.DynamicType node) {
     return const ResolutionDynamicType();
   }
 
   @override
   ResolutionDartType visitInvalidType(ir.InvalidType node) {
     if (topLevel) {
       throw new UnimplementedError(
           "Outermost invalid types not currently supported");
     }
     // Nested invalid types are treated as `dynamic`.
     return const ResolutionDynamicType();
   }
 }
 
-/// Visitor that converts string literals and concatenations of string literals
-/// into the string value.
-class Stringifier extends ir.ExpressionVisitor<String> {
-  @override
-  String visitStringLiteral(ir.StringLiteral node) => node.value;
-
-  @override
-  String visitStringConcatenation(ir.StringConcatenation node) {
-    StringBuffer sb = new StringBuffer();
-    for (ir.Expression expression in node.expressions) {
-      String value = expression.accept(this);
-      if (value == null) return null;
-      sb.write(value);
-    }
-    return sb.toString();
-  }
-}
-
 /// Visitor that converts a kernel constant expression into a
 /// [ConstantExpression].
 class Constantifier extends ir.ExpressionVisitor<ConstantExpression> {
   final KernelAstAdapter astAdapter;
 
   Constantifier(this.astAdapter);
 
   @override
   ConstantExpression visitConstructorInvocation(ir.ConstructorInvocation node) {
     ConstructorElement constructor =
@@ skipping 150 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }