Support user class 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 576 matching lines @@
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     }
 
     constructor.function.positionalParameters.forEach(handleParameter);
     constructor.function.namedParameters.toList()
       ..sort(namedOrdering)
       ..forEach(handleParameter);
 
     // Set the locals handler state as if we were inlining the constructor.
-    ConstructorElement astElement = _elementMap.getConstructor(constructor);
-    ResolvedAst resolvedAst = astElement.resolvedAst;
+    ConstructorEntity astElement = _elementMap.getConstructor(constructor);
     ClosureClassMap oldClosureData = localsHandler.closureData;
     ClosureClassMap newClosureData =
         closureToClassMapper.getMemberMap(astElement);
-    localsHandler.closureData = newClosureData;
-    if (resolvedAst.kind == ResolvedAstKind.PARSED) {
-      localsHandler.enterScope(newClosureData.capturingScopes[resolvedAst.node],
-          forGenerativeConstructorBody: astElement.isGenerativeConstructorBody);
+    if (astElement is ConstructorElement) {
+      // TODO(johnniwinther): Support constructor (body) entities.
+      ResolvedAst resolvedAst = astElement.resolvedAst;
+      localsHandler.closureData = newClosureData;
+      if (resolvedAst.kind == ResolvedAstKind.PARSED) {
+        localsHandler.enterScope(
+            newClosureData.capturingScopes[resolvedAst.node],
+            forGenerativeConstructorBody:
+                astElement.isGenerativeConstructorBody);
+      }
     }
     inlinedFrom(astElement, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
     });
     localsHandler.closureData = oldClosureData;
   }
 
   /// Builds generative constructor body.
   void buildConstructorBody(ir.Constructor constructor) {
     openFunction(constructor.function);
@@ skipping 10 matching lines @@
     if (parent is ir.Procedure && parent.kind == ir.ProcedureKind.Factory) {
       _addClassTypeVariablesIfNeeded(functionNode.parent);
     }
 
     // If [functionNode] is `operator==` we explicitly add a null check at the
     // beginning of the method. This is to avoid having call sites do the null
     // check.
     if (parent is ir.Procedure &&
         parent.kind == ir.ProcedureKind.Operator &&
         parent.name.name == '==') {
-      MethodElement method = _elementMap.getMethod(parent);
+      FunctionEntity method = _elementMap.getMethod(parent);
       if (!backend.operatorEqHandlesNullArgument(method)) {
         handleIf(
           visitCondition: () {
             HParameterValue parameter = parameters.values.first;
             push(new HIdentity(parameter, graph.addConstantNull(closedWorld),
                 null, commonMasks.boolType));
           },
           visitThen: () {
             closeAndGotoExit(new HReturn(
                 graph.addConstantBool(false, closedWorld),
-                sourceInformationBuilder.buildImplicitReturn(method)));
+                // TODO(johnniwinther): Provider source information like
+                // `sourceInformationBuilder.buildImplicitReturn(method)`.
+                null));
           },
           visitElse: null,
           // TODO(27394): Add sourceInformation via
           // `sourceInformationBuilder.buildIf(?)`.
         );
       }
     }
     functionNode.body.accept(this);
     closeFunction();
   }
@@ skipping 2371 matching lines @@
       pop();
       stack.add(graph.addConstantBool(true, closedWorld));
       return;
     }
 
     if (type is ir.DynamicType) {
       stack.add(graph.addConstantBool(true, closedWorld));
       return;
     }
 
-    ResolutionDartType typeValue =
+    DartType typeValue =
         localsHandler.substInContext(_elementMap.getDartType(type));
 
     if (type is ir.FunctionType) {
       HInstruction representation =
           typeBuilder.analyzeTypeArgument(typeValue, sourceElement);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         representation,
       ];
       _pushStaticInvocation(
           _commonElements.functionTypeTest, inputs, commonMasks.boolType);
       HInstruction call = pop();
       push(new HIs.compound(typeValue, expression, call, commonMasks.boolType));
       return;
     }
 
     if (type is ir.TypeParameterType) {
       HInstruction runtimeType =
           typeBuilder.addTypeVariableReference(typeValue, sourceElement);
       _pushStaticInvocation(_commonElements.checkSubtypeOfRuntimeType,
           <HInstruction>[expression, runtimeType], commonMasks.boolType);
       push(
           new HIs.variable(typeValue, expression, pop(), commonMasks.boolType));
       return;
     }
 
     if (_isInterfaceWithNoDynamicTypes(type)) {
+      InterfaceType interfaceType = typeValue;
       HInstruction representations = typeBuilder
           .buildTypeArgumentRepresentations(typeValue, sourceElement);
       add(representations);
-      ClassElement element = typeValue.element;
+      ClassEntity element = interfaceType.element;
       js.Name operator = namer.operatorIs(element);
       HInstruction isFieldName =
           graph.addConstantStringFromName(operator, closedWorld);
       HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
           ? graph.addConstantStringFromName(
               namer.substitutionName(element), closedWorld)
           : graph.addConstantNull(closedWorld);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
@@ skipping 359 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }