Port the remaining of dart:core to the unified corelib.

lib/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('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 426 matching lines @@
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers() => variables.modifiers;
 
   VariableElement(SourceString name,
                   VariableListElement this.variables,
                   ElementKind kind,
                   Element enclosing,
                   [Node node])
-    : super(name, kind, enclosing), cachedNode = node;
+      : super(name, kind, enclosing), cachedNode = node;
+
+  VariableElement.from(SourceString name,
+                       VariableElement other,
+                       Element enclosing)
+      : this(name,
+             new VariableListElement.from(other.variables, enclosing),
+             other.kind,
+             enclosing,
+             other.cachedNode);
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode !== null) return cachedNode;
     VariableDefinitions definitions = variables.parseNode(listener);
     for (Link<Node> link = definitions.definitions.nodes;
          !link.isEmpty(); link = link.tail) {
       Expression initializedIdentifier = link.head;
       Identifier identifier = initializedIdentifier.asIdentifier();
       if (identifier === null) {
         identifier = initializedIdentifier.asSendSet().selector.asIdentifier();
@@ skipping 57 matching lines @@
                       Element enclosing)
     : super(null, kind, enclosing);
 
   VariableListElement.node(VariableDefinitions node,
                            ElementKind kind,
                            Element enclosing)
     : super(null, kind, enclosing),
       this.cachedNode = node,
       this.modifiers = node.modifiers;
 
+  factory VariableListElement.from(VariableListElement other,
+                                   Element enclosing) {
+    var variableList;
+    if (other is PartialFieldListElement) {
+      variableList = new PartialFieldListElement(other.beginToken,
+                                                 other.endToken,
+                                                 other.modifiers,
+                                                 enclosing);
+    } else {
+      variableList = new VariableListElement(other.kind,
+                                             other.modifiers,
+                                             enclosing);
+    }
+    variableList.cachedNode = other.cachedNode;
+    variableList.type = other.type;
+    return variableList;
+  }
+
   VariableDefinitions parseNode(DiagnosticListener listener) {
     return cachedNode;
   }
 
   Type computeType(Compiler compiler) {
     if (type != null) return type;
     VariableDefinitions node = parseNode(compiler);
     if (node.type !== null) {
       type = compiler.resolveTypeAnnotation(this, node.type);
     } else {
@@ skipping 647 matching lines @@
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }