Refactor BackendHelpers to be reusageable with KernelWorldBuilder

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 2036 matching lines @@
   /// Inserts a call to checkDeferredIsLoaded for [prefixElement].
   /// If [prefixElement] is [null] ndo nothing.
   void generateIsDeferredLoadedCheckIfNeeded(
       PrefixElement prefixElement, ast.Node location) {
     if (prefixElement == null) return;
     String loadId =
         compiler.deferredLoadTask.getImportDeferName(location, prefixElement);
     HInstruction loadIdConstant = addConstantString(loadId);
     String uri = prefixElement.deferredImport.uri.toString();
     HInstruction uriConstant = addConstantString(uri);
-    Element helper = helpers.checkDeferredIsLoaded;
+    MethodElement helper = helpers.checkDeferredIsLoaded;
     pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
     pop();
   }
 
   /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
   /// resolves to a deferred library.
   void generateIsDeferredLoadedCheckOfSend(ast.Send node) {
     generateIsDeferredLoadedCheckIfNeeded(
         compiler.deferredLoadTask.deferredPrefixElement(node, elements), node);
   }
@@ skipping 350 matching lines @@
       pushInvokeDynamic(
           node,
           new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
               CallStructure.ONE_ARG),
           null,
           arguments);
       return new HIs.compound(type, expression, pop(), commonMasks.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType =
           typeBuilder.addTypeVariableReference(type, sourceElement);
-      Element helper = helpers.checkSubtypeOfRuntimeType;
+      MethodElement helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, commonMasks.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
-      Element helper = helpers.checkSubtype;
+      MethodElement helper = helpers.checkSubtype;
       HInstruction representations =
           typeBuilder.buildTypeArgumentRepresentations(type, sourceElement);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
       HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(closedWorld);
       List<HInstruction> inputs = <HInstruction>[
         expression,
@@ skipping 243 matching lines @@
       // If the isolate library is not used, we just generate code
       // to fetch the static state.
       String name = backend.namer.staticStateHolder;
       push(new HForeignCode(
           js.js.parseForeignJS(name), commonMasks.dynamicType, <HInstruction>[],
           nativeBehavior: native.NativeBehavior.DEPENDS_OTHER));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
-      Element element = helpers.currentIsolate;
+      MethodElement element = helpers.currentIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       pushInvokeStatic(null, element, [], typeMask: commonMasks.dynamicType);
     }
   }
 
   void handleForeignJsGetFlag(ast.Send node) {
     List<ast.Node> arguments = node.arguments.toList();
     ast.Node argument;
@@ skipping 173 matching lines @@
   void handleForeignJsCallInIsolate(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     if (!backend.hasIsolateSupport) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
       push(new HInvokeClosure(new Selector.callClosure(0),
           <HInstruction>[pop()], commonMasks.dynamicType));
     } else {
       // Call a helper method from the isolate library.
-      Element element = helpers.callInIsolate;
+      MethodElement element = helpers.callInIsolate;
       if (element == null) {
         reporter.internalError(node, 'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
       addGenericSendArgumentsToList(link, inputs);
       pushInvokeStatic(node, element, inputs,
           typeMask: commonMasks.dynamicType);
     }
   }
 
@@ skipping 129 matching lines @@
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
     ConstantValue nameConstant =
         constantSystem.createString(new ast.DartString.literal(publicName));
 
     js.Name internalName = backend.namer.invocationName(selector);
 
-    Element createInvocationMirror = helpers.createInvocationMirror;
+    MethodElement createInvocationMirror = helpers.createInvocationMirror;
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
           constantSystem.createString(new ast.DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
@@ skipping 208 matching lines @@
       inputs.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     });
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, inputs, newObject);
   }
 
   HInstruction callSetRuntimeTypeInfo(
       HInstruction typeInfo, HInstruction newObject) {
     // Set the runtime type information on the object.
-    Element typeInfoSetterElement = helpers.setRuntimeTypeInfo;
+    MethodElement typeInfoSetterElement = helpers.setRuntimeTypeInfo;
     pushInvokeStatic(
         null, typeInfoSetterElement, <HInstruction>[newObject, typeInfo],
         typeMask: commonMasks.dynamicType,
         sourceInformation: newObject.sourceInformation);
 
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
     assert(invariant(CURRENT_ELEMENT_SPANNABLE,
         stack.last is HInvokeStatic || stack.last == newObject,
         message: "Unexpected `stack.last`: Found ${stack.last}, "
             "expected ${newObject} or an HInvokeStatic. "
             "State: typeInfo=$typeInfo, stack=$stack."));
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   void handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
     generateIsDeferredLoadedCheckOfSend(send);
 
+    ConstructorElement constructor = elements[send];
     bool isFixedList = false;
     bool isFixedListConstructorCall = Elements.isFixedListConstructorCall(
-        elements[send], send, closedWorld.commonElements);
+        constructor, send, closedWorld.commonElements);
     bool isGrowableListConstructorCall = Elements.isGrowableListConstructorCall(
-        elements[send], send, closedWorld.commonElements);
+        constructor, send, closedWorld.commonElements);
 
     TypeMask computeType(element) {
-      Element originalElement = elements[send];
+      ConstructorElement originalElement = elements[send];
       if (isFixedListConstructorCall ||
           Elements.isFilledListConstructorCall(
               originalElement, send, closedWorld.commonElements)) {
         isFixedList = true;
         TypeMask inferred = _inferredTypeOfNewList(send);
         return inferred.containsAll(closedWorld)
             ? commonMasks.fixedArrayType
             : inferred;
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred = _inferredTypeOfNewList(send);
@@ skipping 16 matching lines @@
           return new TypeMask.nonNullEmpty();
         } else {
           return new TypeMask.nonNullExact(cls.thisType.element, closedWorld);
         }
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
             originalElement, globalInferenceResults);
       }
     }
 
-    Element constructor = elements[send];
     CallStructure callStructure = elements.getSelector(send).callStructure;
     ConstructorElement constructorDeclaration = constructor;
     ConstructorElement constructorImplementation = constructor.implementation;
     constructor = constructorImplementation.effectiveTarget;
 
     final bool isSymbolConstructor =
         closedWorld.commonElements.isSymbolConstructor(constructorDeclaration);
     final bool isJSArrayTypedConstructor =
         constructorDeclaration == helpers.jsArrayTypedConstructor;
 
@@ skipping 463 matching lines @@
   internalError(Spannable node, String reason) {
     reporter.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
     pushInvokeStatic(node, helper, [errorMessage]);
   }
 
   void generateRuntimeError(ast.Node node, String message) {
-    generateError(node, message, helpers.throwRuntimeError);
+    MethodElement helper = helpers.throwRuntimeError;
+    generateError(node, message, helper);
   }
 
   void generateTypeError(ast.Node node, String message) {
-    generateError(node, message, helpers.throwTypeError);
+    MethodElement helper = helpers.throwTypeError;
+    generateError(node, message, helper);
   }
 
   void generateAbstractClassInstantiationError(ast.Node node, String message) {
-    generateError(node, message, helpers.throwAbstractClassInstantiationError);
+    MethodElement helper = helpers.throwAbstractClassInstantiationError;
+    generateError(node, message, helper);
   }
 
   void generateThrowNoSuchMethod(ast.Node diagnosticNode, String methodName,
       {Link<ast.Node> argumentNodes,
       List<HInstruction> argumentValues,
       List<String> existingArguments,
       SourceInformation sourceInformation}) {
-    Element helper = helpers.throwNoSuchMethod;
+    MethodElement helper = helpers.throwNoSuchMethod;
     ConstantValue receiverConstant =
         constantSystem.createString(new ast.DartString.empty());
     HInstruction receiver = graph.addConstant(receiverConstant, closedWorld);
     ast.DartString dartString = new ast.DartString.literal(methodName);
     ConstantValue nameConstant = constantSystem.createString(dartString);
     HInstruction name = graph.addConstant(nameConstant, closedWorld);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
@@ skipping 231 matching lines @@
     // includes js interop types).
     if (type.element != null && backend.isNative(type.element)) {
       nativeBehavior.typesInstantiated.add(type);
     }
 
     // It also includes any other JS interop type if we don't trust the
     // annotation or if is declared too broad.
     if (!compiler.options.trustJSInteropTypeAnnotations ||
         type.isObject ||
         type.isDynamic) {
-      nativeBehavior.typesInstantiated
-          .add(backend.helpers.jsJavaScriptObjectClass.thisType);
+      ClassElement cls = backend.helpers.jsJavaScriptObjectClass;
+      nativeBehavior.typesInstantiated.add(cls.thisType);
     }
 
     String code;
     if (element.isGetter) {
       code = "#";
     } else if (element.isSetter) {
       code = "# = #";
     } else {
       var args = new List.filled(arguments.length, '#').join(',');
       code = element.isConstructor ? "new #($args)" : "#($args)";
@@ skipping 57 matching lines @@
         // instead.
         element.kind != ElementKind.FIELD) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.add(receiver);
     inputs.addAll(arguments);
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForElement(
           element, globalInferenceResults);
-    } else {
+    } else if (element.isFunction) {
       type = TypeMaskFactory.inferredReturnTypeForElement(
           element, globalInferenceResults);
+    } else {
+      type = closedWorld.commonMasks.dynamicType;
     }
     HInstruction instruction = new HInvokeSuper(element, currentNonClosureClass,
         selector, inputs, type, sourceInformation,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
         closedWorld.getSideEffectsOfSelector(selector, null);
     return instruction;
   }
 
   void handleComplexOperatorSend(
@@ skipping 1141 matching lines @@
     }
     return new JumpHandler(this, element);
   }
 
   visitAsyncForIn(ast.AsyncForIn node) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
     visit(node.expression);
     HInstruction expression = pop();
-    pushInvokeStatic(node, helpers.streamIteratorConstructor,
-        [expression, graph.addConstantNull(closedWorld)]);
+    ConstructorElement constructor = helpers.streamIteratorConstructor;
+    pushInvokeStatic(
+        node, constructor, [expression, graph.addConstantNull(closedWorld)]);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elementInferenceResults.typeOfIteratorMoveNext(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
       push(new HAwait(future,
@@ skipping 272 matching lines @@
     }
     List<HInstruction> listInputs = <HInstruction>[];
     for (Link<ast.Node> link = node.entries.nodes;
         !link.isEmpty;
         link = link.tail) {
       visit(link.head);
       listInputs.add(pop());
       listInputs.add(pop());
     }
 
-    Element constructor;
+    ConstructorElement listConstructor;
     List<HInstruction> inputs = <HInstruction>[];
 
     if (listInputs.isEmpty) {
-      constructor = helpers.mapLiteralConstructorEmpty;
+      listConstructor = helpers.mapLiteralConstructorEmpty;
     } else {
-      constructor = helpers.mapLiteralConstructor;
+      listConstructor = helpers.mapLiteralConstructor;
       HLiteralList keyValuePairs = buildLiteralList(listInputs);
       add(keyValuePairs);
       inputs.add(keyValuePairs);
     }
 
-    assert(constructor.isFactoryConstructor);
+    assert(listConstructor.isFactoryConstructor);
 
-    ConstructorElement functionElement = constructor;
-    constructor = functionElement.effectiveTarget;
+    ConstructorElement constructorElement = listConstructor;
+    listConstructor = constructorElement.effectiveTarget;
 
     ResolutionInterfaceType type = elements.getType(node);
     ResolutionInterfaceType expectedType =
-        functionElement.computeEffectiveTargetType(type);
+        constructorElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
-    ClassElement cls = constructor.enclosingClass;
+    ClassElement cls = listConstructor.enclosingClass;
 
+    MethodElement createFunction = listConstructor;
     if (backend.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
       expectedType.typeArguments.forEach((ResolutionDartType argument) {
         typeInputs
             .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (listInputs.isEmpty) {
-          constructor = helpers.mapLiteralUntypedEmptyMaker;
+          createFunction = helpers.mapLiteralUntypedEmptyMaker;
         } else {
-          constructor = helpers.mapLiteralUntypedMaker;
+          createFunction = helpers.mapLiteralUntypedMaker;
         }
       } else {
         inputs.addAll(typeInputs);
       }
     }
 
     // If rti is needed and the map literal has no type parameters,
     // 'constructor' is a static function that forwards the call to the factory
     // constructor without type parameters.
-    assert(constructor is ConstructorElement || constructor is FunctionElement);
+    assert(createFunction is ConstructorElement ||
+        createFunction is FunctionElement);
 
     // The instruction type will always be a subtype of the mapLiteralClass, but
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
     TypeMask mapType =
         new TypeMask.nonNullSubtype(helpers.mapLiteralClass, closedWorld);
     TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
-        constructor, globalInferenceResults);
+        createFunction, globalInferenceResults);
     TypeMask instructionType =
         mapType.intersection(returnTypeMask, closedWorld);
 
     addInlinedInstantiation(expectedType);
-    pushInvokeStatic(node, constructor, inputs,
+    pushInvokeStatic(node, createFunction, inputs,
         typeMask: instructionType, instanceType: expectedType);
     removeInlinedInstantiation(expectedType);
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(ast.NamedArgument node) {
@@ skipping 1024 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }