A step towards handling `new Object()` in compile_from_dill_test

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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 13 matching lines @@
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/element_map.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/nodes.dart' show Node;
 import '../types/masks.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../universe/use.dart' show DynamicUse;
+import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.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 'switch_continue_analysis.dart';
 import 'type_builder.dart';
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   final ir.Node target;
   final bool _targetIsConstructorBody;
   final MemberEntity targetElement;
 
   /// The root node of [targetElement]. This is used as the key into the
   /// [startFunction] of the locals handler.
   // TODO(johnniwinther,efortuna): Avoid the need for AST nodes in the locals
   // handler.
   final Node functionNode;
   final ClosedWorld closedWorld;
+  final CodegenWorldBuilder _worldBuilder;
   final CodegenRegistry registry;
   final ClosureClassMaps closureToClassMapper;
 
   /// Helper accessor for all kernel function-like targets (Procedure,
   /// FunctionExpression, FunctionDeclaration) of the inner FunctionNode itself.
   /// If the current target is not a function-like target, _targetFunction will
   /// be null.
   ir.FunctionNode _targetFunction;
 
   /// A stack of [ResolutionDartType]s that have been seen during inlining of
@@ skipping 30 matching lines @@
 
   KernelSsaBuilder(
       this.targetElement,
       ClassEntity contextClass,
       this.target,
       this.compiler,
       this._elementMap,
       this._typeInferenceMap,
       this._localsMap,
       this.closedWorld,
+      this._worldBuilder,
       this.registry,
       this.closureToClassMapper,
       // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
       this.sourceInformationBuilder,
       this.functionNode,
       {bool targetIsConstructorBody: false})
       : this._targetIsConstructorBody = targetIsConstructorBody {
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, targetElement,
         contextClass, null, nativeData, interceptorData);
     _targetStack.add(targetElement);
   }
 
   @deprecated // Use [_elementMap] instead.
   KernelAstAdapter get astAdapter => _elementMap;
 
   CommonElements get _commonElements => _elementMap.commonElements;
 
   HGraph build() {
-    // TODO(het): no reason to do this here...
-    HInstruction.idCounter = 0;
-    if (target is ir.Procedure) {
-      _targetFunction = (target as ir.Procedure).function;
-      buildFunctionNode(_targetFunction);
-    } else if (target is ir.Field) {
-      buildField(target);
-    } else if (target is ir.Constructor) {
-      if (_targetIsConstructorBody) {
-        buildConstructorBody(target);
+    return reporter.withCurrentElement(_localsMap.currentMember, () {
+      // TODO(het): no reason to do this here...
+      HInstruction.idCounter = 0;
+      if (target is ir.Procedure) {
+        _targetFunction = (target as ir.Procedure).function;
+        buildFunctionNode(_targetFunction);
+      } else if (target is ir.Field) {
+        buildField(target);
+      } else if (target is ir.Constructor) {
+        if (_targetIsConstructorBody) {
+          buildConstructorBody(target);
+        } else {
+          buildConstructor(target);
+        }
+      } else if (target is ir.FunctionExpression) {
+        _targetFunction = (target as ir.FunctionExpression).function;
+        buildFunctionNode(_targetFunction);
+      } else if (target is ir.FunctionDeclaration) {
+        _targetFunction = (target as ir.FunctionDeclaration).function;
+        buildFunctionNode(_targetFunction);
       } else {
-        buildConstructor(target);
+        throw 'No case implemented to handle target: $target for $targetElement';

[Siggi Cherem (dart-lang), 2017/06/08 18:01:46]

nit: reword to fit under 80?

[Johnni Winther, 2017/06/09 09:28:49]

Split the string.

       }
-    } else if (target is ir.FunctionExpression) {
-      _targetFunction = (target as ir.FunctionExpression).function;
-      buildFunctionNode(_targetFunction);
-    } else if (target is ir.FunctionDeclaration) {
-      _targetFunction = (target as ir.FunctionDeclaration).function;
-      buildFunctionNode(_targetFunction);
-    } else {
-      throw 'No case implemented to handle target: $target for $targetElement';
-    }
-    assert(graph.isValid());
-    return graph;
+      assert(graph.isValid());
+      return graph;
+    });
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
       HInstruction fieldValue = pop();
       HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
           fieldValue, _getDartTypeIfValid(field.type));
       stack.add(checkInstruction);
@@ skipping 94 matching lines @@
 
     // Collect field values for the current class.
     Map<FieldEntity, HInstruction> fieldValues =
         _collectFieldValues(constructedClass);
     List<ir.Constructor> constructorChain = <ir.Constructor>[];
     _buildInitializers(constructor, constructorChain, fieldValues);
 
     final constructorArguments = <HInstruction>[];
     // Doing this instead of fieldValues.forEach because we haven't defined the
     // order of the arguments here. We can define that with JElements.
-    ClassElement cls = _elementMap.getClass(constructedClass);
-    cls.forEachInstanceField(
-        (ClassElement enclosingClass, FieldElement member) {
+    ClassEntity cls = _elementMap.getClass(constructedClass);
+    InterfaceType thisType = _elementMap.getThisType(cls);
+    _worldBuilder.forEachInstanceField(cls,
+        (ClassEntity enclosingClass, FieldEntity member) {
       var value = fieldValues[member];
       assert(value != null, 'No value for field ${member}');
       constructorArguments.add(value);
-    }, includeSuperAndInjectedMembers: true);
+    });
 
     // Create the runtime type information, if needed.
-    bool hasRtiInput = backend.rtiNeed
-        .classNeedsRtiField(_elementMap.getClass(constructedClass));
+    bool hasRtiInput = backend.rtiNeed.classNeedsRtiField(cls);
     if (hasRtiInput) {
       // Read the values of the type arguments and create a HTypeInfoExpression
       // to set on the newly create object.
       List<HInstruction> typeArguments = <HInstruction>[];
       for (ir.DartType typeParameter
           in constructedClass.thisType.typeArguments) {
         HInstruction argument = localsHandler.readLocal(localsHandler
-            .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)
-                as ResolutionTypeVariableType));
+            .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)));
         typeArguments.add(argument);
       }
 
-      ClassElement cls = _elementMap.getClass(constructedClass);
       HInstruction typeInfo = new HTypeInfoExpression(
           TypeInfoExpressionKind.INSTANCE,
-          cls.thisType,
+          thisType,
           typeArguments,
           commonMasks.dynamicType);
       add(typeInfo);
       constructorArguments.add(typeInfo);
     }
 
-    ClassElement constructedCls = _elementMap.getClass(constructedClass);
     HInstruction newObject = new HCreate(
-        _elementMap.getClass(constructedClass),
-        constructorArguments,
-        new TypeMask.nonNullExact(
-            _elementMap.getClass(constructedClass), closedWorld),

[Siggi Cherem (dart-lang), 2017/06/08 18:01:46]

wow... 6 times! 

-        instantiatedTypes: <ResolutionInterfaceType>[constructedCls.thisType],
-        hasRtiInput: hasRtiInput);
+        cls, constructorArguments, new TypeMask.nonNullExact(cls, closedWorld),
+        instantiatedTypes: <InterfaceType>[thisType], hasRtiInput: hasRtiInput);
 
     add(newObject);
 
     // Generate calls to the constructor bodies.
 
     for (ir.Constructor body in constructorChain.reversed) {
       if (_isEmptyStatement(body.function.body)) continue;
 
       List<HInstruction> bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
@@ skipping 3123 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }