Support user class in compile_from_dill_test

pkg/compiler/lib/src/ssa/optimize.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 '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/elements.dart'
     show ClassElement, FieldElement, MethodElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
+import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart';
 import '../js_backend/native_data.dart' show NativeData;
 import '../js_backend/runtime_types.dart';
 import '../native/native.dart' as native;
 import '../options.dart';
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
@@ skipping 746 matching lines @@
         simplifyCondition(node.thenBlock, hoisted, false);
         simplifyCondition(node.elseBlock, hoisted, true);
       });
     }
     simplifyCondition(node.thenBlock, condition, !isNegated);
     simplifyCondition(node.elseBlock, condition, isNegated);
     return node;
   }
 
   HInstruction visitIs(HIs node) {
-    ResolutionDartType type = node.typeExpression;
+    DartType type = node.typeExpression;
 
     if (!node.isRawCheck) {
       return node;
     } else if (type.isTypedef) {
       return node;
     } else if (type.isFunctionType) {
       return node;
     }
 
-    if (type.isObject || type.treatAsDynamic) {
+    if (type == commonElements.objectType || type.treatAsDynamic) {
       return _graph.addConstantBool(true, _closedWorld);
     }
-    ResolutionInterfaceType interfaceType = type;
+    InterfaceType interfaceType = type;
     ClassEntity element = interfaceType.element;
     HInstruction expression = node.expression;
     if (expression.isInteger(_closedWorld)) {
       if (element == commonElements.intClass ||
           element == commonElements.numClass ||
           commonElements.isNumberOrStringSupertype(element)) {
         return _graph.addConstantBool(true, _closedWorld);
       } else if (element == commonElements.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
@@ skipping 1509 matching lines @@
         return;
       }
     }
 
     HTypeKnown newInput = new HTypeKnown.pinned(convertedType, input);
     dominator.addBefore(dominator.first, newInput);
     dominatedUses.replaceWith(newInput);
   }
 
   void visitIs(HIs instruction) {
-    ResolutionDartType type = instruction.typeExpression;
+    DartType type = instruction.typeExpression;
     if (!instruction.isRawCheck) {
       return;
     } else if (type.isTypedef) {
       return;
     }
-    ResolutionInterfaceType interfaceType = type;
+    InterfaceType interfaceType = type;
     ClassEntity cls = interfaceType.element;
 
     List<HBasicBlock> trueTargets = <HBasicBlock>[];
     List<HBasicBlock> falseTargets = <HBasicBlock>[];
 
     collectTargets(instruction, trueTargets, falseTargets);
 
     if (trueTargets.isEmpty && falseTargets.isEmpty) return;
 
     TypeMask convertedType = new TypeMask.nonNullSubtype(cls, closedWorld);
@@ skipping 645 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }