Set runtime type information when converting list literals.

pkg/compiler/lib/src/ssa/builder_kernel.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:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
+import '../tree/tree.dart' as ast;
 import '../types/masks.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart';
 import '../universe/use.dart' show TypeUse;
 import 'graph_builder.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa_branch_builder.dart';
 import 'type_builder.dart';
+import 'types.dart' show TypeMaskFactory;
 
 class SsaKernelBuilderTask extends CompilerTask {
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA kernel builder';
 
   SsaKernelBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : backend = backend,
         super(backend.compiler.measurer);
@@ skipping 158 matching lines @@
   }
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(efortuna): Update this when we implement inlining.
   @override
   Element get sourceElement => astAdapter.getElement(target);
 
   @override
+  void pushInvokeStatic(MethodElement element, List<HInstruction> arguments,

[Harry Terkelsen, 2016/11/15 22:44:48]

This class should not have any methods with Element or Node arguments. The
reason for KernelAstAdapter is so that this class can only ever deal with Kernel
nodes, and not the dart2js Element model. It looks like you need
pushInvokeStatic in order to use it from GraphBuilder. But the GraphBuilder only
needs to make one specific invocation (to backend.helpers.setRuntimeTypeInfo).
Maybe the method in GraphBuilder should be 'setRuntimeTypeInfo(...)' which uses
_pushStaticInvocation in this class and pushInvokeStatic in the normal builder

[Emily Fortuna, 2016/11/16 01:53:44]

Thank you, I intended to get rid of this, but got distracted. Should be fixed
now!

+      {TypeMask typeMask,
+      InterfaceType instanceType,
+      SourceInformation sourceInformation,
+      // TODO(efortuna): Leaving this part of the signature for consistency with
+      // builder.dart. Remove this parameter once we are no longer using
+      // builder.dart.
+      ast.Node location}) {
+    assert(element.isDeclaration);
+    // TODO(efortuna): try to inline method.
+
+    if (typeMask == null) {
+      typeMask =
+          TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
+    }
+    bool targetCanThrow = !compiler.closedWorld.getCannotThrow(element);
+    // TODO(5346): Try to avoid the need for calling [declaration] before

[Harry Terkelsen, 2016/11/15 22:44:48]

this TODO makes no sense to me?

[Emily Fortuna, 2016/11/16 01:53:44]

Agreed.... it was copied from builder.dart. Is it better to leave it out? I
don't know what it means, but I thought I'd leave it in case the person who does
could see it. At any rate, this method is gone from here, so it's not really a
problem anymore. :-P

+    var instruction;
+    if (backend.isJsInterop(element)) {
+      // TODO(efortuna): Implement JS Introp function.
+    } else {
+      // creating an [HInvokeStatic].
+      instruction = new HInvokeStatic(element, arguments, typeMask,
+          targetCanThrow: targetCanThrow)
+        ..sourceInformation = sourceInformation;
+      // TODO(efortuna): Test if we have any inlined instantiations here.
+      instruction.sideEffects =
+          compiler.closedWorld.getSideEffectsOfElement(element);
+    }
+    // TODO(efortuna): Attach source information if available from location.
+    push(instruction);
+  }
+
+  @override
   void visitBlock(ir.Block block) {
     assert(!isAborted());
     for (ir.Statement statement in block.statements) {
       statement.accept(this);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
         if (stack.isNotEmpty) {
           compiler.reporter.internalError(
               NO_LOCATION_SPANNABLE, 'Non-empty instruction stack.');
         }
@@ skipping 316 matching lines @@
     stack.add(graph.addConstant(
         astAdapter.getConstantForSymbol(symbolLiteral), compiler));
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(compiler));
   }
 
+  HInstruction setRtiIfNeeded(HInstruction object, ir.ListLiteral listLiteral) {
+    InterfaceType type = localsHandler
+        .substInContext(elements.getType(astAdapter.getNode(listLiteral)));
+    if (!backend.classNeedsRti(type.element) || type.treatAsRaw) {
+      return object;
+    }
+    List<HInstruction> arguments = <HInstruction>[];
+    for (DartType argument in type.typeArguments) {
+      arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
+    }
+    // TODO(15489): Register at codegen.
+    registry?.registerInstantiation(type);
+    return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
+  }
+
   @override
   void visitListLiteral(ir.ListLiteral listLiteral) {
     HInstruction listInstruction;
     if (listLiteral.isConst) {
       listInstruction =
           graph.addConstant(astAdapter.getConstantFor(listLiteral), compiler);
     } else {
       List<HInstruction> elements = <HInstruction>[];
       for (ir.Expression element in listLiteral.expressions) {
         element.accept(this);
         elements.add(pop());
       }
       listInstruction = new HLiteralList(elements, backend.extendableArrayType);
       add(listInstruction);
-      // TODO(het): set runtime type info
+      listInstruction = setRtiIfNeeded(listInstruction, listLiteral);
     }
 
     TypeMask type = astAdapter.typeOfNewList(targetElement, listLiteral);
     if (!type.containsAll(compiler.closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
   @override
@@ skipping 293 matching lines @@
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }