Resolve typedefs.

tests/compiler/dart2js/resolver_test.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.
 
 #import("../../../lib/compiler/implementation/leg.dart");
 #import("../../../lib/compiler/implementation/elements/elements.dart");
 #import("../../../lib/compiler/implementation/tree/tree.dart");
 #import("../../../lib/compiler/implementation/util/util.dart");
 #import("mock_compiler.dart");
 #import("parser_helper.dart");
@@ skipping 24 matching lines @@
   ResolverVisitor visitor = compiler.resolverVisitor();
   Element element = visitor.visit(createLocals(variables));
   // A VariableDefinitions does not have an element.
   Expect.equals(null, element);
   Expect.equals(variables.length, map(visitor).length);
 
   for (final variable in variables) {
     final name = variable[0];
     Identifier id = buildIdentifier(name);
     final VariableElement variableElement = visitor.visit(id);
-    MethodScope scope = visitor.context;
+    MethodScope scope = visitor.scope;
     Expect.equals(variableElement, scope.elements[buildSourceString(name)]);
   }
   return compiler;
 }
 
 main() {
   testLocalsOne();
   testLocalsTwo();
   testLocalsThree();
   testLocalsFour();
@@ skipping 14 matching lines @@
   testSuperCalls();
   testTypeVariables();
 }
 
 testTypeVariables() {
   matchResolvedTypes(visitor, text, name, expectedElements) {
     VariableDefinitions definition = parseStatement(text);
     visitor.visit(definition.type);
     InterfaceType type = visitor.mapping.getType(definition.type);
     Expect.equals(definition.type.typeArguments.length(),
-                  length(type.arguments));
+                  length(type.typeArguments));
     int index = 0;
-    Link<Type> arguments = type.arguments;
+    Link<Type> arguments = type.typeArguments;
     while (!arguments.isEmpty()) {
       Expect.equals(true, index < expectedElements.length);
       Expect.equals(expectedElements[index], arguments.head.element);
       index++;
       arguments = arguments.tail;
     }
     Expect.equals(index, expectedElements.length);
   }
 
   MockCompiler compiler = new MockCompiler();
@@ skipping 116 matching lines @@
       compiler.errors[0].message);
 }
 
 
 testLocalsTwo() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   Node tree = parseStatement("if (true) { var a = 1; var b = 2; }");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
-  BlockScope scope = visitor.context;
+  BlockScope scope = visitor.scope;
   Expect.equals(0, scope.elements.length);
   Expect.equals(2, map(visitor).length);
 
   List<Element> elements = map(visitor).getValues();
   Expect.notEquals(elements[0], elements[1]);
 }
 
 testLocalsThree() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   Node tree = parseStatement("{ var a = 1; if (true) { a; } }");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
-  BlockScope scope = visitor.context;
+  BlockScope scope = visitor.scope;
   Expect.equals(0, scope.elements.length);
   Expect.equals(3, map(visitor).length);
   List<Element> elements = map(visitor).getValues();
   Expect.equals(elements[0], elements[1]);
 }
 
 testLocalsFour() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   Node tree = parseStatement("{ var a = 1; if (true) { var a = 1; } }");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
-  BlockScope scope = visitor.context;
+  BlockScope scope = visitor.scope;
   Expect.equals(0, scope.elements.length);
   Expect.equals(2, map(visitor).length);
   List<Element> elements = map(visitor).getValues();
   Expect.notEquals(elements[0], elements[1]);
 }
 
 testLocalsFive() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   If tree = parseStatement("if (true) { var a = 1; a; } else { var a = 2; a;}");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
-  BlockScope scope = visitor.context;
+  BlockScope scope = visitor.scope;
   Expect.equals(0, scope.elements.length);
   Expect.equals(6, map(visitor).length);
 
   Block thenPart = tree.thenPart;
   List statements1 = thenPart.statements.nodes.toList();
   Node def1 = statements1[0].definitions.nodes.head;
   Node id1 = statements1[1].expression;
   Expect.equals(visitor.mapping[def1], visitor.mapping[id1]);
 
   Block elsePart = tree.elsePart;
@@ skipping 25 matching lines @@
   Expect.equals(ElementKind.PARAMETER, visitor.mapping[use].kind);
   Expect.equals(visitor.mapping[param], visitor.mapping[use]);
 }
 
 testFor() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   For tree = parseStatement("for (int i = 0; i < 10; i = i + 1) { i = 5; }");
   visitor.visit(tree);
 
-  BlockScope scope = visitor.context;
+  BlockScope scope = visitor.scope;
   Expect.equals(0, scope.elements.length);
   Expect.equals(10, map(visitor).length);
 
   VariableDefinitions initializer = tree.initializer;
   Node iNode = initializer.definitions.nodes.head;
   Element iElement = visitor.mapping[iNode];
 
   // Check that we have the expected nodes. This test relies on the mapping
   // field to be a linked hash map (preserving insertion order).
   Expect.isTrue(map(visitor) is LinkedHashMap);
@@ skipping 395 matching lines @@
 length(Link link) => link.isEmpty() ? 0 : length(link.tail) + 1;
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);
 
 List<String> asSortedStrings(Link link) {
   List<String> result = <String>[];
   for (; !link.isEmpty(); link = link.tail) result.add(link.head.toString());
   result.sort((s1, s2) => s1.compareTo(s2));
   return result;
 }