More equivalence testing

pkg/compiler/lib/src/js_emitter/model.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.new_js_emitter.model;
 
 import '../constants/values.dart' show ConstantValue;
 import '../deferred_load.dart' show OutputUnit;
 import '../elements/entities.dart';
 import '../js/js.dart' as js show Expression, Name, Statement, TokenFinalizer;
@@ skipping 71 matching lines @@
  * classes or functions.
  */
 class Holder {
   final String name;
   final int index;
   final bool isStaticStateHolder;
   final bool isConstantsHolder;
 
   Holder(this.name, this.index,
       {this.isStaticStateHolder: false, this.isConstantsHolder: false});
+
+  String toString() {
+    return 'Holder(name=${name})';
+  }
 }
 
 /**
  * This class represents one output file.
  *
  * If no library is deferred, there is only one [Fragment] of type
  * [MainFragment].
  */
 abstract class Fragment {
   /// The outputUnit should only be used during the transition to the new model.
@@ skipping 35 matching lines @@
       String outputFileName,
       this.invokeMain,
       List<Library> libraries,
       List<StaticField> staticNonFinalFields,
       List<StaticField> staticLazilyInitializedFields,
       List<Constant> constants)
       : super(outputUnit, outputFileName, libraries, staticNonFinalFields,
             staticLazilyInitializedFields, constants);
 
   bool get isMainFragment => true;
+
+  String toString() {
+    return 'MainFragment()';
+  }
 }
 
 /**
  * An output (file) for deferred code.
  */
 class DeferredFragment extends Fragment {
   final String name;
 
   DeferredFragment(
       OutputUnit outputUnit,
       String outputFileName,
       this.name,
       List<Library> libraries,
       List<StaticField> staticNonFinalFields,
       List<StaticField> staticLazilyInitializedFields,
       List<Constant> constants)
       : super(outputUnit, outputFileName, libraries, staticNonFinalFields,
             staticLazilyInitializedFields, constants);
 
   bool get isMainFragment => false;
+
+  String toString() {
+    return 'DeferredFragment(name=${name})';
+  }
 }
 
 class Constant {
   final js.Name name;
   final Holder holder;
   final ConstantValue value;
 
   Constant(this.name, this.holder, this.value);
+
+  String toString() {
+    return 'Constant(name=${name},value=${value.toStructuredText()})';
+  }
 }
 
 abstract class FieldContainer {
   List<Field> get staticFieldsForReflection;
 }
 
 class Library implements FieldContainer {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
   final LibraryEntity element;
 
   final String uri;
   final List<StaticMethod> statics;
   final List<Class> classes;
 
   final List<Field> staticFieldsForReflection;
 
   Library(this.element, this.uri, this.statics, this.classes,
       this.staticFieldsForReflection);
+
+  String toString() {
+    return 'Library(uri=${uri},element=${element})';
+  }
 }
 
 class StaticField {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
   final FieldEntity element;
 
   js.Name name;
   // TODO(floitsch): the holder for static fields is the isolate object. We
   // could remove this field and use the isolate object directly.
   final Holder holder;
   final js.Expression code;
   final bool isFinal;
   final bool isLazy;
 
   StaticField(this.element, this.name, this.holder, this.code, this.isFinal,
       this.isLazy);
+
+  String toString() {
+    return 'StaticField(name=${name},element=${element})';
+  }
 }
 
 class Class implements FieldContainer {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
   final ClassEntity element;
 
   final js.Name name;
   final Holder holder;
   Class _superclass;
@@ skipping 64 matching lines @@
 
   void setSuperclass(Class superclass) {
     _superclass = superclass;
   }
 
   js.Name get superclassName => superclass == null ? null : superclass.name;
 
   int get superclassHolderIndex =>
       (superclass == null) ? 0 : superclass.holder.index;
 
-  String toString() => 'Class(${element.name})';
+  String toString() => 'Class(name=${name},element=$element)';
 }
 
 class MixinApplication extends Class {
   Class _mixinClass;
 
   MixinApplication(
       ClassEntity element,
       js.Name name,
       Holder holder,
       List<Field> instanceFields,
@@ skipping 22 matching lines @@
             isDirectlyInstantiated: isDirectlyInstantiated,
             isNative: false,
             isClosureBaseClass: false);
 
   bool get isMixinApplication => true;
   Class get mixinClass => _mixinClass;
 
   void setMixinClass(Class mixinClass) {
     _mixinClass = mixinClass;
   }
+
+  String toString() => 'Mixin(name=${name},element=$element)';
 }
 
 /// A field.
 ///
 /// In general represents an instance field, but for reflection may also
 /// represent static fields.
 class Field {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
   final FieldEntity element;
@@ skipping 23 matching lines @@
   bool get needsUncheckedSetter => setterFlags != 0;
 
   bool get needsInterceptedGetter => getterFlags > 1;
   bool get needsInterceptedSetter => setterFlags > 1;
 
   bool get needsInterceptedGetterOnReceiver => getterFlags == 2;
   bool get needsInterceptedSetterOnReceiver => setterFlags == 2;
 
   bool get needsInterceptedGetterOnThis => getterFlags == 3;
   bool get needsInterceptedSetterOnThis => setterFlags == 3;
+
+  String toString() {
+    return 'Field(name=${name},element=${element})';
+  }
 }
 
 abstract class Method {
   /// The element should only be used during the transition to the new model.
   /// Uses indicate missing information in the model.
   final MemberEntity element;
 
   /// The name of the method. If the method is a [ParameterStubMethod] for a
   /// static function, then the name can be `null`. In that case, only the
   /// [ParameterStubMethod.callName] should be used.
   final js.Name name;
   final js.Expression code;
 
   Method(this.element, this.name, this.code);
-
-  String toString() {
-    return 'method[name=${name},element=${element}'
-        ',code=${js.nodeToString(code)}]';
-  }
 }
 
 /// A method that corresponds to a method in the original Dart program.
 abstract class DartMethod extends Method {
   final bool needsTearOff;
   final js.Name tearOffName;
   final List<ParameterStubMethod> parameterStubs;
   final bool canBeApplied;
   final bool canBeReflected;
 
@@ skipping 64 matching lines @@
             tearOffName: tearOffName,
             canBeApplied: canBeApplied,
             canBeReflected: canBeReflected,
             requiredParameterCount: requiredParameterCount,
             optionalParameterDefaultValues: optionalParameterDefaultValues,
             functionType: functionType) {
     assert(isClosureCallMethod != null);
   }
 
   bool get isStatic => false;
+
+  String toString() {
+    return 'InstanceMethod(name=${name},element=${element}'
+        ',code=${js.nodeToString(code)})';
+  }
 }
 
 /// A method that is generated by the backend and has not direct correspondence
 /// to a method in the original Dart program. Examples are getter and setter
 /// stubs and stubs to dispatch calls to methods with optional parameters.
 class StubMethod extends Method {
   StubMethod(js.Name name, js.Expression code, {MemberEntity element})
       : super(element, name, code);
 
   String toString() {
-    return 'stub[name=${name},element=${element},code=${js.nodeToString(code)}]';
+    return 'StubMethod(name=${name},element=${element}'
+        ',code=${js.nodeToString(code)})';
   }
 }
 
 /// A stub that adapts and redirects to the main method (the one containing)
 /// the actual code.
 ///
 /// For example, given a method `foo$2(x, [y: 499])` a possible parameter
 /// stub-method could be `foo$1(x) => foo$2(x, 499)`.
 ///
 /// ParameterStubMethods are always attached to (static or instance) methods.
 class ParameterStubMethod extends StubMethod {
   /// The `call` name of this stub.
   ///
   /// When an instance method is torn off, it is invoked as a `call` member and
   /// not it's original name anymore. The [callName] provides the stub's
   /// name when it is used this way.
   ///
   /// If a stub's member can not be torn off, the [callName] is `null`.
   js.Name callName;
 
   ParameterStubMethod(js.Name name, this.callName, js.Expression code)
       : super(name, code);
+
+  String toString() {
+    return 'ParameterStubMethod(name=${name},element=${element}'
+        ',code=${js.nodeToString(code)})';
+  }
 }
 
 abstract class StaticMethod implements Method {
   Holder get holder;
 }
 
 class StaticDartMethod extends DartMethod implements StaticMethod {
   final Holder holder;
 
   StaticDartMethod(
@@ skipping 15 matching lines @@
             tearOffName: tearOffName,
             canBeApplied: canBeApplied,
             canBeReflected: canBeReflected,
             requiredParameterCount: requiredParameterCount,
             optionalParameterDefaultValues: optionalParameterDefaultValues,
             functionType: functionType);
 
   bool get isStatic => true;
 
   String toString() {
-    return 'static_method[name=${name},element=${element}}]';
+    return 'StaticDartMethod(name=${name},element=${element}'
+        ',code=${js.nodeToString(code)})';
   }
 }
 
 class StaticStubMethod extends StubMethod implements StaticMethod {
   Holder holder;
   StaticStubMethod(js.Name name, this.holder, js.Expression code)
       : super(name, code);
+
+  String toString() {
+    return 'StaticStubMethod(name=${name},element=${element}}'
+        ',code=${js.nodeToString(code)})';
+  }
 }