Refactor ConstantSystem

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
@@ skipping 94 matching lines @@
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
       _compiler.globalInference.results;
 
   GlobalTypeInferenceElementResult _resultOf(Element e) =>
       _globalInferenceResults
           .resultOf(e is ConstructorBodyElementX ? e.constructor : e);
 
   ConstantValue getConstantForSymbol(ir.SymbolLiteral node) {
     if (kernel.syntheticNodes.contains(node)) {
-      return _backend.constantSystem.createSymbol(_compiler, node.value);
+      return _backend.constantSystem.createSymbol(
+          _compiler.commonElements, _backend.backendClasses, node.value);
     }
     ast.Node astNode = getNode(node);
     ConstantValue constantValue = _backend.constants
         .getConstantValueForNode(astNode, _resolvedAst.elements);
     assert(invariant(astNode, constantValue != null,
         message: 'No constant computed for $node'));
     return constantValue;
   }
 
   // TODO(johnniwinther): Use the more precise functions below.
@@ skipping 178 matching lines @@
     //         defaultExpression.accept(new Constantifier(this));
     //     assert(constantExpression != null);
     ConstantExpression constantExpression =
         kernel.parameterInitializerNodeToConstant[defaultExpression];
     if (constantExpression == null) return null;
     return _backend.constants.getConstantValue(constantExpression);
   }
 
   ConstantValue getConstantForType(ir.DartType irType) {
     ResolutionDartType type = getDartType(irType);
-    return _backend.constantSystem.createType(_compiler, type.asRaw());
+    return _backend.constantSystem.createType(
+        _compiler.commonElements, _backend.backendClasses, type.asRaw());
   }
 
   bool isIntercepted(ir.Node node) {
     Selector selector = getSelector(node);
     return _backend.interceptorData.isInterceptedSelector(selector);
   }
 
   bool isInterceptedSelector(Selector selector) {
     return _backend.interceptorData.isInterceptedSelector(selector);
   }
@@ skipping 501 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }