Dart2js option to dump info about compilation

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
 
 import '../dart2jslib.dart' show invariant,
                                  InterfaceType,
                                  DartType,
                                  TypeVariableType,
                                  TypedefType,
                                  DualKind,
                                  MessageKind,
                                  DiagnosticListener,
                                  Script,
                                  FunctionType,
                                  Selector,
                                  Constant,
                                  Compiler,
-                                 isPrivateName;
+                                 isPrivateName,
+                                 CodeBuffer;

[ahe, 2013/11/27 19:28:53]

This import doesn't belong here.

[sigurdm, 2013/11/29 10:39:37]

Done.

 
 import '../dart_types.dart';
 
 import '../scanner/scannerlib.dart' show Token, EOF_TOKEN;
 
 import '../ordered_typeset.dart' show OrderedTypeSet;
 
 class ElementX implements Element {
   static int elementHashCode = 0;
 
@@ skipping 249 matching lines @@
   FunctionElement asFunctionElement() => null;
 
   static bool isInvalid(Element e) => e == null || e.isErroneous();
 
   bool get isAbstract => modifiers.isAbstract();
   bool isForeign(Compiler compiler) => getLibrary() == compiler.foreignLibrary;
 
   FunctionElement get targetConstructor => null;
 
   void diagnose(Element context, DiagnosticListener listener) {}
+
+  Map collectInferredTypes(Compiler compiler) {
+    compiler.internalError("This element does not support dumping of types",
+                           token: position());
+  }
 }
 
 /**
  * Represents an unresolvable or duplicated element.
  *
  * An [ErroneousElement] is used instead of [null] to provide additional
  * information about the error that caused the element to be unresolvable
  * or otherwise invalid.
  *
  * Accessing any field or calling any method defined on [ErroneousElement]
@@ skipping 681 matching lines @@
       return 'origin library(${getLibraryOrScriptName()})';
     } else {
       return 'library(${getLibraryOrScriptName()})';
     }
   }
 
   int compareTo(LibraryElement other) {
     if (this == other) return 0;
     return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
   }
+
+  Map collectInferredTypes(Compiler compiler) {

[ahe, 2013/11/27 19:28:53]

This really doesn't seem to be an essential part of the element model.

There are no inferred types in the element model, so elements cannot collect
inferred types.

I think it is time to add an element visitor an implement this using visitors.

From an object oriented modeling perspective, there are some problematic things
below, such as calling back to the backend to collect emitted code. Such things
are not a concern of elements. However, if this code is implemented as a
visitor, the visitor is concerned with collecting information from various
sources, and thus it is a concern of the visitor to access diverse sources such
as element model and backend data.

[sigurdm, 2013/11/29 10:39:37]

I agree

I have made a visitor

+    List contents = [];
+    int size = compiler.backend.codeSizeCounter.generatedSize(this);
+    if (size == 0) return null;
+
+    forEachLocalMember((Element element) {
+      Map info = element.collectInferredTypes(compiler);
+      if (info != null) {
+        contents.add(info);
+      }
+    });
+
+    String nameString = getLibraryName() == "" ? "<unnamed>" : getLibraryName();
+    contents.sort((Map m1, Map m2) => m1["name"].compareTo(m2["name"]));
+    return {
+      "type" : this.canonicalUri.toString(),

[ahe, 2013/11/27 19:28:53]

Generally, try to create classes instead of simple data types. Long term, that
really improves maintainability.

[sigurdm, 2013/11/29 10:39:37]

Yes - the map'o'maps was more for drafting purposes

Done

+      "kind" : "library",
+      "name" : nameString,
+      "size" : size,
+      "modifiers" : "",
+      "contents" : contents
+      };
+  }
 }
 
 class PrefixElementX extends ElementX implements PrefixElement {
   Token firstPosition;
 
   final ImportScope importScope = new ImportScope();
 
   PrefixElementX(String prefix, Element enclosing, this.firstPosition)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
+
+

[ahe, 2013/11/27 19:28:53]

Extra lines.

[sigurdm, 2013/11/29 10:39:37]

Done.

 }
 
 class TypedefElementX extends ElementX implements TypedefElement {
   Typedef cachedNode;
 
   /**
    * The type of this typedef in which the type arguments are the type
    * variables.
    *
    * This resembles the [ClassElement.thisType] though a typedef has no notion
@@ skipping 63 matching lines @@
   Scope buildScope() {
     return new TypeDeclarationScope(enclosingElement.buildScope(), this);
   }
 
   void checkCyclicReference(Compiler compiler) {
     if (hasBeenCheckedForCycles) return;
     var visitor = new TypedefCyclicVisitor(compiler, this);
     computeType(compiler).accept(visitor, null);
     hasBeenCheckedForCycles = true;
   }
+
+  Map collectInferredTypes(Compiler compiler) {
+    if (thisType == null) {

[karlklose, 2013/11/27 14:19:23]

Merge this int l. 1136 using '?:' ?

[sigurdm, 2013/11/29 10:39:37]

Done.

+      return null;
+    }
+    return {
+      "type" : thisType.toString(),
+      "kind" : "typedef",
+      "name" : name,
+      "modifiers" : "",
+      };
+  }
 }
 
 class VariableElementX extends ElementX implements VariableElement {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElementX(String name,
                    VariableListElement variables,
@@ skipping 24 matching lines @@
     return variables.computeType(compiler);
   }
 
   DartType get type => variables.type;
 
   bool isInstanceMember() => variables.isInstanceMember();
 
   // Note: cachedNode.getBeginToken() will not be correct in all
   // cases, for example, for function typed parameters.
   Token position() => findMyName(variables.position());
+
+  Map collectInferredTypes(Compiler compiler) {
+    if (type == null) {
+      return null;
+    }
+    String modifiersString = modifiers.toString() == "" ?
+        "" : modifiers.toString()+" ";
+    List inferredType = [{
+      "kind" : "inferred type",
+      "name" : "",
+      "type" : compiler.typesTask.getGuaranteedTypeOfElement(this).toString(),
+      "modifiers" : ""
+    }];
+    return {
+      "kind" : "field",
+      "type" : type.toString(),
+      "name" : name,
+      "modifiers" : modifiersString,
+      "contents" : inferredType
+    };
+  }
 }
 
 /**
  * Parameters in constructors that directly initialize fields. For example:
  * [:A(this.field):].
  */
 class FieldParameterElementX extends VariableElementX
     implements FieldParameterElement {
   VariableElement fieldElement;
 
@@ skipping 389 matching lines @@
     } else {
       return super.toString();
     }
   }
 
   bool get isAbstract {
     return !modifiers.isExternal() &&
            (isFunction() || isAccessor()) &&
            _hasNoBody;
   }
+
+  Map collectInferredTypes(Compiler compiler) {
+    CodeBuffer emittedCode = compiler.backend.emitCodeFor(this);
+    if (emittedCode == null) {
+      return null;
+    }
+    String modifiersString = modifiers.toString() == "" ?
+        "" : modifiers.toString()+" ";
+    String kindString = "function";
+    String nameString = name;
+    if (isConstructor()) {
+      nameString = name == "" ? "${enclosingElement.name}()" :
+        "${enclosingElement.name}.$name";
+      kindString = "constructor";
+    }
+    if (type == null) {
+      return {
+        "type" : "not used",
+        "kind" : kindString,
+        "name" : nameString,
+        "modifiers" : modifiersString
+      };
+    }
+    List contents = [];
+    FunctionSignature signature = computeSignature(compiler);
+    signature.forEachParameter((parameter) {
+      contents.add({
+        "kind" : "inferred",
+        "name" : parameter.name,
+        "modifiers" : "parameter type",
+        "type" :
+          compiler.typesTask.getGuaranteedTypeOfElement(parameter).toString()
+      });
+    });
+    contents.add({
+      "kind" : "inferred",
+      "name" : "",
+      "modifiers" : "return type",
+      "type" :
+        compiler.typesTask.getGuaranteedReturnTypeOfElement(this).toString()
+    });
+    contents.add({
+      "kind" : "inferred",
+      "name" : "",
+      "modifiers" : "side effects",
+      "type" : compiler.world.getSideEffectsOfElement(this).toString()
+    });
+    contents.add({
+      "name" : "Generated code",
+      "presentation" : "code",
+      "text" : emittedCode.getText()
+    });
+    return {
+      "type" : type.toString(),
+      "kind" : kindString,
+      "name" : nameString,
+      "size" : emittedCode.length,
+      "modifiers" : modifiersString,
+      "contents" : contents
+    };
+  }
 }
 
 class ConstructorBodyElementX extends FunctionElementX
     implements ConstructorBodyElement {
   FunctionElement constructor;
 
   ConstructorBodyElementX(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
@@ skipping 139 matching lines @@
   int supertypeLoadState;
   int resolutionState;
   bool get isResolved => resolutionState == STATE_DONE;
 
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const Link<Element>();
 
   OrderedTypeSet allSupertypesAndSelf;
 
-  Link<DartType> get allSupertypes => allSupertypesAndSelf.supertypes;
+  Link<DartType> get allSupertypes {
+    assert(invariant(this, allSupertypesAndSelf != null,

[ahe, 2013/11/27 19:28:53]

This invariant is unnecessary. You get a null pointer when it fails.

[sigurdm, 2013/11/29 10:39:37]

Done.

+        message: "This class has not been resolved "
+                 "(trying to access allSupertypes)"));
+    return allSupertypesAndSelf.supertypes;
+  }
 
   int get hierarchyDepth => allSupertypesAndSelf.maxDepth;
 
   BaseClassElementX(String name,
                     Element enclosing,
                     this.id,
                     int initialState)
       : supertypeLoadState = initialState,
         resolutionState = initialState,
         super(name, ElementKind.CLASS, enclosing);
@@ skipping 372 matching lines @@
     for (ClassElement s = declaration; s != null; s = s.superclass) {
       if (identical(s, cls)) return true;
     }
     return false;
   }
 
   bool isNative() => nativeTagInfo != null;
   void setNative(String name) {
     nativeTagInfo = name;
   }
+
+  Map collectInferredTypes(Compiler compiler) {
+    String modifiersString = modifiers.toString() == "" ?
+        "" : modifiers.toString()+" ";
+    if (!isResolved) return null;
+    String supersString = allSupertypes == null ? "" :
+        "implements $allSupertypes";
+    List contents = [];
+    forEachLocalMember((Element element) {
+      Map info = element.collectInferredTypes(compiler);
+      if (info != null) {
+        contents.add(info);
+      }
+    });
+    if (contents.isEmpty) {
+      return null;
+    }
+    contents.sort((Map m1, Map m2) => m1["name"].compareTo(m2["name"]));
+    return {
+      "kind" : "class",
+      "name" : name,
+      "type" : supersString,
+      "modifiers" : modifiersString,
+      "contents" : contents
+      };
+  }
 }
 
 abstract class ClassElementX extends BaseClassElementX {
   // Lazily applied patch of class members.
   ClassElement patch = null;
   ClassElement origin = null;
 
   Link<Element> localMembers = const Link<Element>();
   final ScopeX localScope = new ScopeX();
 
@@ skipping 272 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }