Change interfaces to abstract classes in dart2js compiler.

lib/compiler/implementation/ssa/builder.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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 691 matching lines @@
 // Represents a single break/continue instruction.
 class JumpHandlerEntry {
   final HJump jumpInstruction;
   final LocalsHandler locals;
   bool isBreak() => jumpInstruction is HBreak;
   bool isContinue() => jumpInstruction is HContinue;
   JumpHandlerEntry(this.jumpInstruction, this.locals);
 }
 
 
-interface JumpHandler default JumpHandlerImpl {
-  JumpHandler(SsaBuilder builder, TargetElement target);
+abstract class JumpHandler {
+  factory JumpHandler(SsaBuilder builder, TargetElement target) {

[ngeoffray, 2012/09/12 09:30:56]

You know that this won't be valid after we switch to the new spec, right?

[Lasse Reichstein Nielsen, 2012/09/12 10:17:46]

I think it'll still be valid. We still need normal factory methods, and not
forwarding constructors (that may or may not be generative for the class they
forward to).

+    return new TargetJumpHandler(builder, target);
+  }
   void generateBreak([LabelElement label]);
   void generateContinue([LabelElement label]);
   void forEachBreak(void action(HBreak instruction, LocalsHandler locals));
   void forEachContinue(void action(HContinue instruction,
                                    LocalsHandler locals));
   void close();
   final TargetElement target;
   List<LabelElement> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
   final Compiler compiler;
+
   NullJumpHandler(this.compiler);
 
   void generateBreak([LabelElement label]) {
-    // TODO(lrn): Need a compiler object and a location. Since label
-    // is optional, it may be null so we also need a position.
     compiler.internalError('generateBreak should not be called');
   }
 
   void generateContinue([LabelElement label]) {
-    // TODO(lrn): Need a compiler object and a location. Since label
-    // is optional, it may be null so we also need a position.
     compiler.internalError('generateContinue should not be called');
   }
 
   void forEachBreak(Function ignored) { }
   void forEachContinue(Function ignored) { }
   void close() { }
-  final TargetElement target = null;
+
   List<LabelElement> labels() => const <LabelElement>[];
+  TargetElement get target => null;
 }
 
 // Records breaks until a target block is available.
 // Breaks are always forward jumps.
 // Continues in loops are implemented as breaks of the body.
 // Continues in switches is currently not handled.
-class JumpHandlerImpl implements JumpHandler {
+class TargetJumpHandler implements JumpHandler {
   final SsaBuilder builder;
   final TargetElement target;
   final List<JumpHandlerEntry> jumps;
 
-  JumpHandlerImpl(SsaBuilder builder, this.target)
+  TargetJumpHandler(SsaBuilder builder, this.target)
       : this.builder = builder,
         jumps = <JumpHandlerEntry>[] {
     assert(builder.jumpTargets[target] === null);
     builder.jumpTargets[target] = this;
   }
 
   void generateBreak([LabelElement label]) {
     HInstruction breakInstruction;
     if (label === null) {
       breakInstruction = new HBreak(target);
@@ skipping 3370 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }