Cleanup 1: split parts into their own libraries, remove unused imports

pkg/compiler/lib/src/ssa/nodes.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.
 
-part of ssa;
+
+import '../closure.dart';
+import '../common.dart';
+import '../compiler.dart' show Compiler;
+import '../constants/constant_system.dart';
+import '../constants/values.dart';
+import '../dart_types.dart';
+import '../elements/elements.dart';
+import '../io/source_information.dart';
+import '../js/js.dart' as js;
+import '../js_backend/backend_helpers.dart' show BackendHelpers;
+import '../js_backend/js_backend.dart';
+import '../native/native.dart' as native;
+import '../tree/dartstring.dart' as ast;
+import '../types/constants.dart' show computeTypeMask;
+import '../types/types.dart';
+import '../universe/selector.dart' show Selector;
+import '../universe/side_effects.dart' show SideEffects;
+import '../util/util.dart';
+import '../world.dart' show ClassWorld, World;
+
+import 'validate.dart';
+import 'invoke_dynamic_specializers.dart';
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitAwait(HAwait node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
@@ skipping 2871 matching lines @@
       : super(<HInstruction>[input], type) {
     sourceElement = input.sourceElement;
   }
 
   bool get isMovable => false;
 
   accept(HVisitor visitor) => visitor.visitRangeConversion(this);
 }
 
 class HStringConcat extends HInstruction {
-  final ast.Node node;
-  HStringConcat(HInstruction left, HInstruction right, this.node, TypeMask type)
+  HStringConcat(HInstruction left, HInstruction right, TypeMask type)
       : super(<HInstruction>[left, right], type) {
     // TODO(sra): Until Issue 9293 is fixed, this false dependency keeps the
     // concats bunched with stringified inputs for much better looking code with
     // fewer temps.
     sideEffects.setDependsOnSomething();
   }
 
   HInstruction get left => inputs[0];
   HInstruction get right => inputs[1];
 
   accept(HVisitor visitor) => visitor.visitStringConcat(this);
   toString() => "string concat";
 }
 
 /**
  * The part of string interpolation which converts and interpolated expression
  * into a String value.
  */
 class HStringify extends HInstruction {
-  final ast.Node node;
-  HStringify(HInstruction input, this.node, TypeMask type)
+  HStringify(HInstruction input, TypeMask type)
       : super(<HInstruction>[input], type) {
     sideEffects.setAllSideEffects();
     sideEffects.setDependsOnSomething();
   }
 
   accept(HVisitor visitor) => visitor.visitStringify(this);
   toString() => "stringify";
 }
 
 /** Non-block-based (aka. traditional) loop information. */
@@ skipping 162 matching lines @@
                                     {this.isContinue: false})
       : this.labels = const<LabelDefinition>[];
 
   HBasicBlock get start => body.start;
   HBasicBlock get end => body.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitLabeledBlockInfo(this);
 }
 
-class LoopTypeVisitor extends ast.Visitor {
-  const LoopTypeVisitor();
-  int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
-  int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
-  int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
-  int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
-  int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
-  int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
-  int visitSwitchStatement(ast.SwitchStatement node) =>
-      HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
-}
-
 class HLoopBlockInformation implements HStatementInformation {
   static const int WHILE_LOOP = 0;
   static const int FOR_LOOP = 1;
   static const int DO_WHILE_LOOP = 2;
   static const int FOR_IN_LOOP = 3;
   static const int SWITCH_CONTINUE_LOOP = 4;
   static const int NOT_A_LOOP = -1;
 
   final int kind;
   final HExpressionInformation initializer;
@@ skipping 29 matching lines @@
   }
 
   HBasicBlock get end {
     if (updates != null) return updates.end;
     if (kind == DO_WHILE_LOOP && condition != null) {
       return condition.end;
     }
     return body.end;
   }
 
-  static int loopType(ast.Node node) {
-    return node.accept(const LoopTypeVisitor());
-  }
-
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitLoopInfo(this);
 }
 
 class HIfBlockInformation implements HStatementInformation {
   final HExpressionInformation condition;
   final HStatementInformation thenGraph;
   final HStatementInformation elseGraph;
   HIfBlockInformation(this.condition,
                       this.thenGraph,
@@ skipping 165 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }