Add synthetic type variables to unnamed mixin applications.

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';
@@ skipping 1752 matching lines @@
   int get hashCode => id;
   ClassElement get patch => super.patch;
   ClassElement get origin => super.origin;
   ClassElement get declaration => super.declaration;
   ClassElement get implementation => super.implementation;
 
   bool get hasBackendMembers => !backendMembers.isEmpty;
 
   bool get isUnnamedMixinApplication => false;
 
-  // TODO(johnniwinther): Add [thisType] getter similar to [rawType].
-  InterfaceType computeType(Compiler compiler) {
+  void computeThisAndRawType(Compiler compiler, Link<DartType> typeVariables) {
     if (thisType == null) {
       if (origin == null) {
-        Link<DartType> parameters = computeTypeParameters(compiler);
+        Link<DartType> parameters = typeVariables;
         thisType = new InterfaceType(this, parameters);
         if (parameters.isEmpty) {
           rawTypeCache = thisType;
         } else {
           var dynamicParameters = const Link<DartType>();
           parameters.forEach((_) {
             dynamicParameters =
                 dynamicParameters.prepend(compiler.types.dynamicType);
           });
           rawTypeCache = new InterfaceType(this, dynamicParameters);
         }
       } else {
         thisType = origin.computeType(compiler);
         rawTypeCache = origin.rawType;
       }
     }
+  }
+
+  // TODO(johnniwinther): Add [thisType] getter similar to [rawType].
+  InterfaceType computeType(Compiler compiler) {
+    if (thisType == null) {
+      computeThisAndRawType(compiler, computeTypeParameters(compiler));
+    }
     return thisType;
   }
 
   InterfaceType get rawType {
     assert(invariant(this, rawTypeCache != null,
                      message: 'Raw type has not been computed for $this'));
     return rawTypeCache;
   }
 
   Link<DartType> computeTypeParameters(Compiler compiler);
@@ skipping 485 matching lines @@
     constructors = constructors.prepend(constructor);
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     assert(!hasConstructor);
     addConstructor(constructor);
   }
 
   Link<DartType> computeTypeParameters(Compiler compiler) {
     NamedMixinApplication named = node.asNamedMixinApplication();
-    if (named == null) return const Link<DartType>();
+    if (named == null) {
+      throw new SpannableAssertionFailure(node,
+          "Type variables on unnamed mixin applications must be set on "
+          "creation.");
+    }
     return TypeDeclarationElementX.createTypeVariables(
         this, named.typeParameters);
   }
 
   accept(ElementVisitor visitor) => visitor.visitMixinApplicationElement(this);
 }
 
 class LabelElementX extends ElementX implements LabelElement {
 
   // We store the original label here so it can be returned by [parseNode].
@@ skipping 60 matching lines @@
   String toString() => statement.toString();
 
   accept(ElementVisitor visitor) => visitor.visitTargetElement(this);
 }
 
 class TypeVariableElementX extends ElementX implements TypeVariableElement {
   final Node cachedNode;
   TypeVariableType type;
   DartType bound;
 
-  TypeVariableElementX(name, Element enclosing, this.cachedNode,
+  TypeVariableElementX(String name, Element enclosing, this.cachedNode,
                        [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name}";
 
   Token position() => cachedNode.getBeginToken();
@@ skipping 43 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }