Support general handling of type variables by substituting types into the current context.

sdk/lib/_internal/compiler/implementation/elements/elements.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.
 
 library elements;
 
 
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
@@ skipping 227 matching lines @@
   Token position();
 
   CompilationUnitElement getCompilationUnit();
   LibraryElement getLibrary();
   LibraryElement getImplementationLibrary();
   ClassElement getEnclosingClass();
   Element getEnclosingClassOrCompilationUnit();
   Element getEnclosingMember();
   Element getOutermostEnclosingMemberOrTopLevel();
 
+  /// The enclosing class that defines the type environment for this element.
+  ClassElement get contextClass;
+
   FunctionElement asFunctionElement();
 
   bool get isPatched;
   bool get isPatch;
   bool get isImplementation;
   bool get isDeclaration;
   bool get isSynthesized;
   bool get isForwardingConstructor;
   bool get isMixinApplication;
 
@@ skipping 600 matching lines @@
 
 abstract class ConstructorBodyElement extends FunctionElement {
   FunctionElement get constructor;
 }
 
 /**
  * [TypeDeclarationElement] defines the common interface for class/interface
  * declarations and typedefs.
  */
 abstract class TypeDeclarationElement extends Element {
+  /**
+   * The `this type` for this type declaration.
+   *
+   * The type of [:this:] is the generic type based on this element in which
+   * the type arguments are the declared type variables. For instance,
+   * [:List<E>:] for [:List:] and [:Map<K,V>:] for [:Map:].
+   *
+   * For a class declaration this is the type of [:this:].
+   */
   GenericType get thisType;
+
+  /**
+   * The raw type for this type declaration.
+   *
+   * The raw type is the generic type base on this element in which the type
+   * arguments are all [dynamic]. For instance [:List<dynamic>:] for [:List:]
+   * and [:Map<dynamic,dynamic>:] for [:Map:]. For non-generic classes [rawType]
+   * is the same as [thisType].
+   *
+   * The [rawType] field is a canonicalization of the raw type and should be
+   * used to distinguish explicit and implicit uses of the [dynamic]
+   * type arguments. For instance should [:List:] be the [rawType] of the
+   * [:List:] class element whereas [:List<dynamic>:] should be its own
+   * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
+   * this distinction, we can print the raw type with type arguments only when
+   * the input source has used explicit type arguments.
+   */
   GenericType get rawType;
 
   /**
    * The type variables declared on this declaration. The type variables are not
    * available until the type of the element has been computed through
    * [computeType].
    */
   Link<DartType> get typeVariables;
 
   bool get isResolved;
 }
 
 abstract class ClassElement extends TypeDeclarationElement
     implements ScopeContainerElement {
   int get id;
 
   /// The length of the longest inheritance path from [:Object:].
   int get hierarchyDepth;
 
   InterfaceType get rawType;
   InterfaceType get thisType;
-
   ClassElement get superclass;
 
+  /// The direct supertype of this class.
   DartType get supertype;
+
+  /// Ordered set of all supertypes of this class.
   OrderedTypeSet get allSupertypesAndSelf;
+
+  /// A list of all

[karlklose, 2014/05/07 12:46:37]

Comment is incomplete.

[Johnni Winther, 2014/05/08 07:03:59]

Done.

   Link<DartType> get allSupertypes;
+
+  /// Returns the this type of this class as an instance of [cls]:

[karlklose, 2014/05/07 12:46:37]

Is there missing something? If not, terminate with '.'.

[Johnni Winther, 2014/05/08 07:03:59]

Done.

+  InterfaceType asInstanceOf(ClassElement cls);
+
+  /// A list of all direct superinterfaces of this class.
   Link<DartType> get interfaces;
 
   bool get hasConstructor;
   Link<Element> get constructors;
 
   ClassElement get patch;
   ClassElement get origin;
   ClassElement get declaration;
   ClassElement get implementation;
 
@@ skipping 232 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }