Improve dumping of inferred types.

pkg/analyzer/lib/src/summary/link.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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 954 matching lines @@
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return resolveTypeRef(type.typeArguments[i], typeParameterContext);
         } else {
           return DynamicTypeImpl.instance;
         }
       }
-      ReferenceableElementForLink element = _resolveRef(type.reference);
+      ReferenceableElementForLink element = resolveRef(type.reference);
       return element.buildType(
           getTypeArgument, type.implicitFunctionTypeIndices);
     }
   }
 
-  @override
-  String toString() => enclosingElement.toString();
-
   /**
    * Return the element referred to by the given [index] in
    * [UnlinkedUnit.references].  If the reference is unresolved,
    * return [UndefinedElementForLink.instance].
    */
-  ReferenceableElementForLink _resolveRef(int index) {
+  ReferenceableElementForLink resolveRef(int index) {
     if (_references[index] == null) {
       UnlinkedReference unlinkedReference =
           index < _unlinkedUnit.references.length
               ? _unlinkedUnit.references[index]
               : null;
       LinkedReference linkedReference = _linkedUnit.references[index];
       String name = unlinkedReference == null
           ? linkedReference.name
           : unlinkedReference.name;
       int containingReference = unlinkedReference == null
           ? linkedReference.containingReference
           : unlinkedReference.prefixReference;
       if (containingReference != 0 &&
           _linkedUnit.references[containingReference].kind !=
               ReferenceKind.prefix) {
         if (linkedReference.kind == ReferenceKind.function) {
           // Local function
-          _references[index] = _resolveRef(containingReference)
+          _references[index] = resolveRef(containingReference)
                   .getLocalFunction(linkedReference.localIndex) ??
               UndefinedElementForLink.instance;
         } else {
           _references[index] =
-              _resolveRef(containingReference).getContainedName(name);
+              resolveRef(containingReference).getContainedName(name);
         }
       } else if (linkedReference.dependency == 0) {
         if (name == 'void') {
           _references[index] = enclosingElement._linker.voidElement;
         } else if (name == '*bottom*') {
           _references[index] = enclosingElement._linker.bottomElement;
         } else if (name == 'dynamic') {
           _references[index] = enclosingElement._linker.dynamicElement;
         } else {
           _references[index] = enclosingElement.getContainedName(name);
         }
       } else {
         LibraryElementForLink dependency =
             enclosingElement._getDependency(linkedReference.dependency);
         _references[index] = dependency.getContainedName(name);
       }
     }
     return _references[index];
   }
+
+  @override
+  String toString() => enclosingElement.toString();
 }
 
 /**
  * Element representing a compilation unit which is part of the build
  * unit being linked.
  */
 class CompilationUnitElementInBuildUnit extends CompilationUnitElementForLink {
   @override
   final LinkedUnitBuilder _linkedUnit;
 
@@ skipping 359 matching lines @@
 
   /**
    * If [constructorElement] redirects to another constructor via a factory
    * redirect, return the constructor it redirects to.
    */
   ConstructorElementForLink _getFactoryRedirectedConstructor() {
     EntityRef redirectedConstructor =
         constructorElement._unlinkedExecutable.redirectedConstructor;
     if (redirectedConstructor != null) {
       return constructorElement.compilationUnit
-          ._resolveRef(redirectedConstructor.reference)
+          .resolveRef(redirectedConstructor.reference)
           .asConstructor;
     } else {
       return null;
     }
   }
 }
 
 /**
  * Specialization of [DependencyWalker] for detecting constant
  * evaluation cycles.
@@ skipping 38 matching lines @@
     if (unlinkedConst == null) {
       return;
     }
     int refPtr = 0;
     for (UnlinkedConstOperation operation in unlinkedConst.operations) {
       switch (operation) {
         case UnlinkedConstOperation.pushReference:
         case UnlinkedConstOperation.invokeMethodRef:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstVariableNode variable =
-              compilationUnit._resolveRef(ref.reference).asConstVariable;
+              compilationUnit.resolveRef(ref.reference).asConstVariable;
           if (variable != null) {
             dependencies.add(variable);
           }
           break;
         case UnlinkedConstOperation.makeTypedList:
           refPtr++;
           break;
         case UnlinkedConstOperation.makeTypedMap:
           refPtr += 2;
           break;
         case UnlinkedConstOperation.invokeConstructor:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstructorElementForLink element =
-              compilationUnit._resolveRef(ref.reference).asConstructor;
+              compilationUnit.resolveRef(ref.reference).asConstructor;
           if (element?._constNode != null) {
             dependencies.add(element._constNode);
           }
           break;
         default:
           break;
       }
     }
     assert(refPtr == unlinkedConst.references.length);
   }
@@ skipping 767 matching lines @@
 
   void _doInvokeConstructor() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     // TODO(paulberry): don't just pop the args; use their types
     // to infer the type of type arguments.
     stack.length -= numNamed + numPositional;
     strPtr += numNamed;
     EntityRef ref = _getNextRef();
     ConstructorElementForLink element =
-        unit._resolveRef(ref.reference).asConstructor;
+        unit.resolveRef(ref.reference).asConstructor;
     if (element != null) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       stack.add(enclosingClass.buildType((int i) {
         // Type argument explicitly specified.
         if (i < ref.typeArguments.length) {
           return unit.resolveTypeRef(
               ref.typeArguments[i], variable._typeParameterContext);
         }
         // In strong mode, type argument defaults to bound (if any).
         if (linker.strongMode) {
@@ skipping 34 matching lines @@
     }());
   }
 
   void _doInvokeMethodRef() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
     List<DartType> positionalArgTypes = _popList(numPositional);
     EntityRef ref = _getNextRef();
-    ReferenceableElementForLink element = unit._resolveRef(ref.reference);
+    ReferenceableElementForLink element = unit.resolveRef(ref.reference);
     stack.add(() {
       DartType rawType = element.asStaticType;
       if (rawType is FunctionType) {
         FunctionType inferredType = _inferExecutableType(rawType, numNamed,
             numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
         if (inferredType != null) {
           return inferredType.returnType;
         }
       }
       return DynamicTypeImpl.instance;
@@ skipping 45 matching lines @@
     EntityRef ref = _getNextRef();
     if (ref.paramReference != 0) {
       stack.add(typeProvider.typeType);
     } else {
       // Synthetic function types can't be directly referred
       // to by expressions.
       assert(ref.syntheticReturnType == null);
       // Nor can implicit function types derived from
       // function-typed parameters.
       assert(ref.implicitFunctionTypeIndices.isEmpty);
-      ReferenceableElementForLink element = unit._resolveRef(ref.reference);
+      ReferenceableElementForLink element = unit.resolveRef(ref.reference);
       stack.add(element.asStaticType);
     }
   }
 
   int _getNextInt() {
     return unlinkedConst.ints[intPtr++];
   }
 
   EntityRef _getNextRef() => unlinkedConst.references[refPtr++];
 
@@ skipping 501 matching lines @@
       }
       return new FunctionTypeImpl.elementWithNameAndArgs(
           this, name, typeArguments, true);
     } else {
       return _type ??= new FunctionTypeImpl.forTypedef(this);
     }
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Specialization of [DependencyWalker] for linking library cycles.
  */
 class LibraryCycleDependencyWalker extends DependencyWalker<LibraryCycleNode> {
   @override
   void evaluate(LibraryCycleNode v) {
     v.link();
   }
@@ skipping 658 matching lines @@
     return DynamicTypeImpl.instance;
   }
 
   @override
   TypeInferenceNode get asTypeInferenceNode => _target.asTypeInferenceNode;
 
   @override
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_library, this, name);
   }
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  String toString() => '$_target.(dynamic)$_name';
 }
 
 /**
  * Element representing a function or method parameter resynthesized
  * from a summary during linking.
  */
 class ParameterElementForLink implements ParameterElementImpl {
   /**
    * The unlinked representation of the parameter in the summary.
    */
@@ skipping 443 matching lines @@
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Base class representing an element which can be the target of a reference.
  * When used as a mixin, implements the default behavior shared by most
  * elements.
  */
-class ReferenceableElementForLink {
+abstract class ReferenceableElementForLink implements Element {
   /**
    * If this element can be used in a constructor invocation context,
    * return the associated constructor (which may be `this` or some
    * other element).  Otherwise return `null`.
    */
   ConstructorElementForLink get asConstructor => null;
 
   /**
    * If this element can be used in a getter context to refer to a
    * constant variable, return the [ConstVariableNode] for the
@@ skipping 54 matching lines @@
   SpecialTypeElementForLink(this.linker, this.type);
 
   @override
   DartType get asStaticType => linker.typeProvider.typeType;
 
   @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     return type;
   }
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  String toString() => type.toString();
 }
 
 /**
  * Element representing a synthetic variable resynthesized from a summary during
  * linking.
  */
 class SyntheticVariableElementForLink implements PropertyInducingElementImpl {
   PropertyAccessorElementForLink_Executable _getter;
   PropertyAccessorElementForLink_Executable _setter;
 
@@ skipping 38 matching lines @@
   ElementKind get kind => ElementKind.FUNCTION;
 
   @override
   FunctionElementForLink_Local getLocalFunction(int index) {
     // TODO(paulberry): implement.
     return null;
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 class TopLevelVariableElementForLink extends VariableElementForLink
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElementForLink enclosingElement,
       UnlinkedVariable unlinkedVariable)
@@ skipping 75 matching lines @@
     }
     int refPtr = 0;
 
     for (UnlinkedConstOperation operation in unlinkedConst.operations) {
       switch (operation) {
         case UnlinkedConstOperation.pushReference:
           EntityRef ref = unlinkedConst.references[refPtr++];
           // TODO(paulberry): cache these resolved references for
           // later use by evaluate().
           TypeInferenceNode dependency =
-              compilationUnit._resolveRef(ref.reference).asTypeInferenceNode;
+              compilationUnit.resolveRef(ref.reference).asTypeInferenceNode;
           if (dependency != null) {
             dependencies.add(dependency);
           }
           break;
         case UnlinkedConstOperation.makeTypedList:
         case UnlinkedConstOperation.invokeConstructor:
           refPtr++;
           break;
         case UnlinkedConstOperation.makeTypedMap:
           refPtr += 2;
@@ skipping 189 matching lines @@
 }
 
 /**
  * Singleton element used for unresolved references.
  */
 class UndefinedElementForLink extends Object with ReferenceableElementForLink {
   static final UndefinedElementForLink instance =
       new UndefinedElementForLink._();
 
   UndefinedElementForLink._();
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a top level variable resynthesized from a
  * summary during linking.
  */
 abstract class VariableElementForLink
     implements NonParameterVariableElementImpl, PropertyInducingElement {
   /**
    * The unlinked representation of the variable in the summary.
@@ skipping 135 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }