Stub implementation of patch invariants for the patch refactoring.

lib/compiler/implementation/typechecker.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 TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
   static const bool LOG_FAILURES = false;
 
   void check(Node tree, TreeElements elements) {
     measure(() {
       Visitor visitor =
           new TypeCheckerVisitor(compiler, elements, compiler.types);
       try {
         tree.accept(visitor);
       } on CancelTypeCheckException catch (e) {
         if (LOG_FAILURES) {
           // Do not warn about unimplemented features; log message instead.
           compiler.log("'${e.node}': ${e.reason}");
         }
       }
     });
   }
 }
 
 abstract class DartType implements Hashable {
   abstract SourceString get name;
+  /**
+   * Returns the [Element] which declared this type.
+   *
+   * This can be [ClassElement] for classes, [TypedefElement] for typedefs,
+   * [TypeVariableElement] for type variables and [FunctionElement] for
+   * function types.
+   *
+   * Invariant: [element] must be a declaration element.
+   */
   abstract Element get element;
 
   /**
    * Returns the unaliased type of this type.
    *
    * The unaliased type of a typedef'd type is the unaliased type to which its
    * name is bound. The unaliased version of any other type is the type itself.
    *
    * For example, the unaliased type of [: typedef A Func<A,B>(B b) :] is the
    * function type [: (B) -> A :] and the unaliased type of
@@ skipping 108 matching lines @@
     return arguments == other.arguments;
   }
 }
 
 class FunctionType implements DartType {
   final Element element;
   DartType returnType;
   Link<DartType> parameterTypes;
 
   FunctionType(DartType this.returnType, Link<DartType> this.parameterTypes,
-               Element this.element);
+               Element this.element) {
+    assert(element == null || invariant(element, element.isDeclaration));

[ahe, 2012/09/20 11:12:07]

===

[Johnni Winther, 2012/09/21 09:18:25]

Done.

+  }
 
   DartType unalias(Compiler compiler) => this;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     bool first = true;
     sb.add('(');
     parameterTypes.printOn(sb, ', ');
     sb.add(') -> ${returnType}');
     return sb.toString();
@@ skipping 738 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     return unhandledStatement();
   }
 
   visitTypedef(Typedef node) {
     return unhandledStatement();
   }
 }