Remove element from DynamicType.

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 '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 983 matching lines @@
 
   // Only needed for deferred imports.
   Import _deferredImport;
   Import get deferredImport => _deferredImport;
 
   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;
+  DartType computeType(Compiler compiler) => const DynamicType();
 
   Token get position => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
 
   void markAsDeferred(Import deferredImport) {
@@ skipping 601 matching lines @@
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super("loadLibrary",
               ElementKind.FUNCTION,
               Modifiers.EMPTY,
               prefix, true);
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignature;
     compiler.withCurrentElement(this, () {
-      DartType inner = new FunctionType(this, compiler.types.dynamicType);
+      DartType inner = new FunctionType(this);
       functionSignatureCache = new FunctionSignatureX(const Link(),
           const Link(), 0, 0, false, [], inner);
     });
     return functionSignatureCache;
   }
 
   bool get isMember => false;
 
   bool isForeign(Compiler compiler) => true;
 
@@ skipping 151 matching lines @@
         message: "This type has already been set on $this."));
     assert(invariant(this, rawTypeCache == null,
         message: "Raw type has already been set on $this."));
     thisTypeCache = createType(typeParameters);
     if (typeParameters.isEmpty) {
       rawTypeCache = thisTypeCache;
     } else {
       Link<DartType> dynamicParameters = const Link<DartType>();
       typeParameters.forEach((_) {
         dynamicParameters =
-            dynamicParameters.prepend(compiler.types.dynamicType);
+            dynamicParameters.prepend(const DynamicType());
       });
       rawTypeCache = createType(dynamicParameters);
     }
   }
 
   Link<DartType> get typeVariables => thisType.typeArguments;
 
   /**
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
@@ skipping 753 matching lines @@
     assert(invariant(this, this.origin == null,
                      message: "Origin element is a patch."));
     assert(invariant(patch, patch.origin == null,
                      message: "Element is patched twice."));
     assert(invariant(patch, patch.patch == null,
                      message: "Patch element is patched."));
     this.patch = patch;
     patch.origin = this;
   }
 }