Issue 4238. Infer Element subclass from query() parameter

compiler/javatests/com/google/dart/compiler/type/TypeAnalyzerCompilerTest.java

 // 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.
 package com.google.dart.compiler.type;
 
 import com.google.common.base.Joiner;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.dart.compiler.CommandLineOptions.CompilerOptions;
@@ skipping 1785 matching lines @@
           "  var v = a;",
           "  v.f = 0;",
           "  v.m();",
           "}",
           "");
       assertErrors(result.getErrors());
     }
   }
 
   public void test_typesPropagation_assignAtDeclaration() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "f() {",
         "  var v0 = true;",
         "  var v1 = true && false;",
         "  var v2 = 1;",
         "  var v3 = 1 + 2;",
         "  var v4 = 1.0;",
         "  var v5 = 1.0 + 2.0;",
         "  var v6 = new Map<String, int>();",
         "  var v7 = new Map().length;",
         "  var v8 = Math.random();",
         "}",
         "");
     // prepare expected results
     List<String> expectedList = Lists.newArrayList();
     expectedList.add("bool");
     expectedList.add("bool");
     expectedList.add("int");
     expectedList.add("int");
     expectedList.add("double");
     expectedList.add("double");
     expectedList.add("Map<String, int>");
     expectedList.add("int");
     expectedList.add("double");
     // check each "v" type
     for (int i = 0; i < expectedList.size(); i++) {
       String expectedTypeString = expectedList.get(i);
-      assertInferredElementTypeString(libraryResult, "v" + i, expectedTypeString);
+      assertInferredElementTypeString(testUnit, "v" + i, expectedTypeString);
     }
   }
 
   public void test_typesPropagation_secondAssign_sameType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f() {",
         "  var v = true;",
         "  v = false;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "bool");
+    assertInferredElementTypeString(testUnit, "v", "bool");
   }
 
   public void test_typesPropagation_secondAssign_differentType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f() {",
         "  var v = true;",
         "  v = 0;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v", "<dynamic>");
   }
 
   /**
    * When we can not identify type of assigned value we should keep "Dynamic" as type of variable.
    */
   public void test_typesPropagation_assign_newUnknownType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "f() {",
         "  var v1 = new Unknown();",
         "  var v2 = new Unknown.name();",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
-    assertInferredElementTypeString(libraryResult, "v2", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v2", "<dynamic>");
   }
 
   public void test_typesPropagation_ifAsType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if ((v as String).length != 0) {",
         "    var v1 = v;",
         "  }",
         "  var v2 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
-    assertInferredElementTypeString(libraryResult, "v2", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v2", "<dynamic>");
   }
 
   /**
    * Even if there is negation, we still apply "as" cast, so visit "then" statement only if cast was
    * successful.
    */
   public void test_typesPropagation_ifAsType_negation() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (!(v as String).isEmpty()) {",
         "    var v1 = v;",
         "  }",
         "  var v2 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
-    assertInferredElementTypeString(libraryResult, "v2", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v2", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "f(var v) {",
         "  if (v is List<String>) {",
         "    var v1 = v;",
         "  }",
         "  if (v is Map<int, String>) {",
         "    var v2 = v;",
         "  }",
         "  var v3 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "List<String>");
-    assertInferredElementTypeString(libraryResult, "v2", "Map<int, String>");
-    assertInferredElementTypeString(libraryResult, "v3", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "List<String>");
+    assertInferredElementTypeString(testUnit, "v2", "Map<int, String>");
+    assertInferredElementTypeString(testUnit, "v3", "<dynamic>");
   }
 
   /**
    * We should not make variable type less specific, even if there is such (useless) user code.
    */
   public void test_typesPropagation_ifIsType_mostSpecific() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "f() {",
         "  int a;",
         "  num b;",
         "  if (a is num) {",
         "    var a1 = a;",
         "  }",
         "  if (a is Dynamic) {",
         "    var a2 = a;",
         "  }",
         "  if (b is int) {",
         "    var b1 = b;",
         "  }",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "a1", "int");
-    assertInferredElementTypeString(libraryResult, "a2", "int");
-    assertInferredElementTypeString(libraryResult, "b1", "int");
+    assertInferredElementTypeString(testUnit, "a1", "int");
+    assertInferredElementTypeString(testUnit, "a2", "int");
+    assertInferredElementTypeString(testUnit, "b1", "int");
   }
 
   /**
    * When single variable has conflicting type constraints, right now we don't try to unify them,
    * instead we fall back to "Dynamic".
    */
   public void test_typesPropagation_ifIsType_conflictingTypes() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(int v) {",
         "  if (v is String) {",
         "    var v1 = v;",
         "  }",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsType_negation() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "f(var v) {",
         "  if (v is! String) {",
         "    var v1 = v;",
         "  }",
         "  if (!(v is String)) {",
         "    var v2 = v;",
         "  }",
         "  if (!!(v is String)) {",
         "    var v3 = v;",
         "  }",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
-    assertInferredElementTypeString(libraryResult, "v2", "<dynamic>");
-    assertInferredElementTypeString(libraryResult, "v3", "String");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v2", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v3", "String");
   }
 
   public void test_typesPropagation_ifIsType_and() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var a, var b) {",
         "  if (a is String && b is List<String>) {",
         "    var a1 = a;",
         "    var b1 = b;",
         "  }",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "a1", "String");
-    assertInferredElementTypeString(libraryResult, "b1", "List<String>");
+    assertInferredElementTypeString(testUnit, "a1", "String");
+    assertInferredElementTypeString(testUnit, "b1", "List<String>");
   }
 
   public void test_typesPropagation_ifIsType_or() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (true || v is String) {",
         "    var v1 = v;",
         "  }",
         "  if (v is String || true) {",
         "    var v2 = v;",
         "  }",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
-    assertInferredElementTypeString(libraryResult, "v2", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v2", "<dynamic>");
   }
 
   public void test_typesPropagation_whileIsType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  var v = null;",
         "  while (v is String) {",
         "    var v1 = v;",
         "  }",
         "  var v2 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
-    assertInferredElementTypeString(libraryResult, "v2", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v2", "<dynamic>");
   }
 
   public void test_typesPropagation_forIsType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  var v = null;",
         "  for (; v is String; () {var v2 = v;} ()) {",
         "    var v1 = v;",
         "  }",
         "  var v3 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
-    assertInferredElementTypeString(libraryResult, "v2", "String");
-    assertInferredElementTypeString(libraryResult, "v3", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v2", "String");
+    assertInferredElementTypeString(testUnit, "v3", "<dynamic>");
   }
 
   public void test_typesPropagation_forEach() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  List<String> values = [];",
         "  for (var v in values) {",
         "    var v1 = v;",
         "  }",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v1", "String");
   }
 
   public void test_typesPropagation_ifIsNotType_withElse() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (v is! String) {",
         "    var v1 = v;",
         "  } else {",
         "    var v2 = v;",
         "  }",
         "  var v3 = v;",
         "}",
         "");
     // we don't know type, but not String
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
     // we know that String
-    assertInferredElementTypeString(libraryResult, "v2", "String");
+    assertInferredElementTypeString(testUnit, "v2", "String");
     // again, we don't know after "if"
-    assertInferredElementTypeString(libraryResult, "v3", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v3", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsNotType_hasThenReturn() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  var v1 = v;",
         "  if (v is! String) {",
         "    return;",
         "  }",
         "  var v2 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
-    assertInferredElementTypeString(libraryResult, "v2", "String");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v2", "String");
   }
 
   public void test_typesPropagation_ifIsNotType_hasThenThrow() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (v is! String) {",
         "    throw new Exception();",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v1", "String");
   }
 
   public void test_typesPropagation_ifIsNotType_emptyThen() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (v is! String) {",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsNotType_otherThen() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (v is! String) {",
         "    ;",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsNotType_hasThenThrow_withCatch() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  try {",
         "    if (v is! String) {",
         "      throw new Exception();",
         "    }",
         "  } catch (var e) {",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsNotType_or() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var p1, var p2) {",
         "  if (p1 is! int || p2 is! String) {",
         "    return;",
         "  }",
         "  var v1 = p1;",
         "  var v2 = p2;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "int");
-    assertInferredElementTypeString(libraryResult, "v2", "String");
+    assertInferredElementTypeString(testUnit, "v1", "int");
+    assertInferredElementTypeString(testUnit, "v2", "String");
   }
 
   public void test_typesPropagation_ifIsNotType_and() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (v is! String && true) {",
         "    return;",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsNotType_not() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (!(v is! String)) {",
         "    return;",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "<dynamic>");
+    assertInferredElementTypeString(testUnit, "v1", "<dynamic>");
   }
 
   public void test_typesPropagation_ifIsNotType_not2() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (!!(v is! String)) {",
         "    return;",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v1", "String");
   }
 
   public void test_typesPropagation_ifNotIsType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
+        "// filler filler filler filler filler filler filler filler filler filler",
         "f(var v) {",
         "  if (!(v is String)) {",
         "    return;",
         "  }",
         "  var v1 = v;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "String");
+    assertInferredElementTypeString(testUnit, "v1", "String");
   }
 
   public void test_typesPropagation_field_inClass() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class A {",
         "  var v1 = 123;",
         "  var v2 = Math.random();",
         "  var v3 = 1 + 2.0;",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "int");
-    assertInferredElementTypeString(libraryResult, "v2", "double");
-    assertInferredElementTypeString(libraryResult, "v3", "double");
+    assertInferredElementTypeString(testUnit, "v1", "int");
+    assertInferredElementTypeString(testUnit, "v2", "double");
+    assertInferredElementTypeString(testUnit, "v3", "double");
   }
 
   public void test_typesPropagation_field_topLevel() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "var v1 = 123;",
         "var v2 = Math.random();",
         "var v3 = 1 + 2.0;",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "int");
-    assertInferredElementTypeString(libraryResult, "v2", "double");
-    assertInferredElementTypeString(libraryResult, "v3", "double");
+    assertInferredElementTypeString(testUnit, "v1", "int");
+    assertInferredElementTypeString(testUnit, "v2", "double");
+    assertInferredElementTypeString(testUnit, "v3", "double");
   }
 
   public void test_typesPropagation_FunctionAliasType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "typedef F();",
         "foo(F f) {",
         "  var v = f;",
         "  v();",
         "}",
         "",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "F");
+    assertInferredElementTypeString(testUnit, "v", "F");
   }
 
   /**
    * When we pass "function literal" into invocation on some method, we may know exact
    * <code>Function</code> type expected by this method, so we know types of "function literal"
    * parameters. So, if these types are not specified in "function literal", we can use "expected"
    * types.
    * <p>
    * http://code.google.com/p/dart/issues/detail?id=3712
    */
   public void test_typesPropagation_parameterOfClosure_invocationNormalParameter() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Event {}",
         "typedef void EventListener(Event event);",
         "foo(EventListener listener) {",
         "}",
         "main() {",
         "  foo((e) {",
         "    var v = e;",
         "  });",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "Event");
+    assertInferredElementTypeString(testUnit, "v", "Event");
   }
 
   /**
    * <p>
    * http://code.google.com/p/dart/issues/detail?id=3712
    */
   public void test_typesPropagation_parameterOfClosure_invocationNamedPositionalParameter() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Event {}",
         "typedef void EventListener(Event event);",
         "foo([EventListener listener]) {",
         "}",
         "main() {",
         "  foo((e) {",
         "    var v = e;",
         "  });",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "Event");
+    assertInferredElementTypeString(testUnit, "v", "Event");
   }
 
   /**
    * <p>
    * http://code.google.com/p/dart/issues/detail?id=3712
    */
   public void test_typesPropagation_parameterOfClosure_invocationNamedParameter() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Event {}",
         "typedef void EventListener(Event event);",
         "foo([EventListener listener]) {",
         "}",
         "main() {",
         "  foo(listener: (e) {",
         "    var v = e;",
         "  });",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "Event");
+    assertInferredElementTypeString(testUnit, "v", "Event");
   }
 
   /**
    * http://code.google.com/p/dart/issues/detail?id=3712
    */
   public void test_typesPropagation_parameterOfClosure_invocationOfMethod() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Event {}",
         "typedef void EventListener(Event event);",
         "class Button {",
         "  onClick(EventListener listener) {",
         "  }",
         "}",
         "main() {",
         "  Button button = new Button();",
         "  button.onClick((e) {",
         "    var v = e;",
         "  });",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "Event");
+    assertInferredElementTypeString(testUnit, "v", "Event");
   }
 
   /**
    * We should infer closure parameter types even in {@link FunctionType} is specified directly,
    * without using {@link FunctionAliasType}.
    */
   public void test_typesPropagation_parameterOfClosure_functionType() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "class Event {}",
         "class Button<T> {",
         "  onClick(listener(T e)) {",
         "  }",
         "}",
         "main() {",
         "  var button = new Button<Event>();",
         "  button.onClick((e) {",
         "    var v = e;",
         "  });",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v", "Event");
+    assertInferredElementTypeString(testUnit, "v", "Event");
   }
 
   public void test_getType_binaryExpression() throws Exception {
-    AnalyzeLibraryResult libraryResult = analyzeLibrary(
+    analyzeLibrary(
         "f(var arg) {",
         "  var v1 = 1 + 2;",
         "  var v2 = 1 - 2;",
         "  var v3 = 1 * 2;",
         "  var v4 = 1 ~/ 2;",
         "  var v5 = 1 % 2;",
         "  var v6 = 1 / 2;",
         "  var v7 = 1.0 + 2;",
         "  var v8 = 1 + 2.0;",
         "  var v9 = 1 - 2.0;",
         "  var v10 = 1.0 - 2;",
         "  var v11 = 1 * 2.0;",
         "  var v12 = 1.0 * 2;",
         "  var v13 = 1.0 / 2;",
         "  var v14 = 1 / 2.0;",
         "  var v15 = 1.0 ~/ 2.0;",
         "  var v16 = 1.0 ~/ 2;",
         "  var v17 = arg as int",
         "}",
         "");
-    assertInferredElementTypeString(libraryResult, "v1", "int");
-    assertInferredElementTypeString(libraryResult, "v2", "int");
-    assertInferredElementTypeString(libraryResult, "v3", "int");
-    assertInferredElementTypeString(libraryResult, "v4", "int");
-    assertInferredElementTypeString(libraryResult, "v5", "int");
-    assertInferredElementTypeString(libraryResult, "v6", "double");
-    assertInferredElementTypeString(libraryResult, "v7", "double");
-    assertInferredElementTypeString(libraryResult, "v8", "double");
-    assertInferredElementTypeString(libraryResult, "v9", "double");
-    assertInferredElementTypeString(libraryResult, "v10", "double");
-    assertInferredElementTypeString(libraryResult, "v11", "double");
-    assertInferredElementTypeString(libraryResult, "v12", "double");
-    assertInferredElementTypeString(libraryResult, "v13", "double");
-    assertInferredElementTypeString(libraryResult, "v14", "double");
-    assertInferredElementTypeString(libraryResult, "v15", "double");
-    assertInferredElementTypeString(libraryResult, "v16", "double");
-    assertInferredElementTypeString(libraryResult, "v17", "int");
+    assertInferredElementTypeString(testUnit, "v1", "int");
+    assertInferredElementTypeString(testUnit, "v2", "int");
+    assertInferredElementTypeString(testUnit, "v3", "int");
+    assertInferredElementTypeString(testUnit, "v4", "int");
+    assertInferredElementTypeString(testUnit, "v5", "int");
+    assertInferredElementTypeString(testUnit, "v6", "double");
+    assertInferredElementTypeString(testUnit, "v7", "double");
+    assertInferredElementTypeString(testUnit, "v8", "double");
+    assertInferredElementTypeString(testUnit, "v9", "double");
+    assertInferredElementTypeString(testUnit, "v10", "double");
+    assertInferredElementTypeString(testUnit, "v11", "double");
+    assertInferredElementTypeString(testUnit, "v12", "double");
+    assertInferredElementTypeString(testUnit, "v13", "double");
+    assertInferredElementTypeString(testUnit, "v14", "double");
+    assertInferredElementTypeString(testUnit, "v15", "double");
+    assertInferredElementTypeString(testUnit, "v16", "double");
+    assertInferredElementTypeString(testUnit, "v17", "int");
   }
 
   /**
    * It was requested that even if Editor can be helpful and warn about types incompatibility, it
    * should not do this to completely satisfy specification.
    * <p>
    * http://code.google.com/p/dart/issues/detail?id=3223
    */
   public void test_typesPropagation_noExtraWarnings() throws Exception {
     AnalyzeLibraryResult libraryResult = analyzeLibrary(
@@ skipping 32 matching lines @@
         "  var a = new A();",
         "  var v1 = a.intProperty;",
         "  var v2 = a.boolProperty;",
         "  if (a.boolProperty) {",
         "  }",
         "  if (!a.boolProperty) {",
         "  }",
         "}",
         "");
     assertErrors(libraryResult.getErrors());
-    assertInferredElementTypeString(libraryResult, "v1", "int");
-    assertInferredElementTypeString(libraryResult, "v2", "bool");
+    assertInferredElementTypeString(testUnit, "v1", "int");
+    assertInferredElementTypeString(testUnit, "v2", "bool");
   }
 
   public void test_getType_getterInNegation_generic() throws Exception {
     AnalyzeLibraryResult libraryResult = analyzeLibrary(
         "class A<T> {",
         "  T field;",
         "  T get prop() => null;",
         "}",
         "f() {",
         "  var a = new A<bool>();",
         "  var v1 = a.field;",
         "  var v2 = a.prop;",
         "  if (a.field) {",
         "  }",
         "  if (!a.field) {",
         "  }",
         "  if (a.prop) {",
         "  }",
         "  if (!a.prop) {",
         "  }",
         "}",
         "");
     assertErrors(libraryResult.getErrors());
-    assertInferredElementTypeString(libraryResult, "v1", "bool");
-    assertInferredElementTypeString(libraryResult, "v2", "bool");
+    assertInferredElementTypeString(testUnit, "v1", "bool");
+    assertInferredElementTypeString(testUnit, "v2", "bool");
   }
 
   public void test_getType_getterInSwitch_default() throws Exception {
     AnalyzeLibraryResult libraryResult = analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "int get foo() {}",
         "f() {",
         "  switch (true) {",
         "    default:",
         "      int v = foo;",
@@ skipping 36 matching lines @@
         "  switch (a.foo) {",
         "    case 2:",
         "      break;",
         "  }",
         "}",
         "");
     assertErrors(libraryResult.getErrors());
   }
 
   /**
-   * Asserts that {@link Element} with given name has expected type.
-   */
-  private void assertInferredElementTypeString(
-      AnalyzeLibraryResult libraryResult,
-      String variableName,
-      String expectedType) {
-    // find element
-    Element element = getNamedElement(libraryResult, variableName);
-    assertNotNull(element);
-    // check type
-    Type actualType = element.getType();
-    assertEquals(element.getName(), expectedType, actualType.toString());
-    // should be inferred
-    if (TypeKind.of(actualType) != TypeKind.DYNAMIC) {
-      assertTrue("Should be marked as inferred", actualType.isInferred());
-    }
-  }
-
-  /**
-   * @return the {@link Element} with given name, may be <code>null</code>.
-   */
-  private Element getNamedElement(AnalyzeLibraryResult libraryResult, final String name) {
-    DartUnit unit = libraryResult.getLibraryUnitResult().getUnit(getName());
-    final Element[] result = {null};
-    unit.accept(new ASTVisitor<Void>() {
-      @Override
-      public Void visitIdentifier(DartIdentifier node) {
-        Element element = node.getElement();
-        if (element != null && element.getName().equals(name)) {
-          result[0] = element;
-        }
-        return super.visitIdentifier(node);
-      }
-    });
-    return result[0];
-  }
-
-  /**
    * <p>
    * http://code.google.com/p/dart/issues/detail?id=3272
    */
   public void test_assignVoidToDynamic() throws Exception {
     AnalyzeLibraryResult libraryResult = analyzeLibrary(
         "// filler filler filler filler filler filler filler filler filler filler",
         "void foo() {}",
         "main() {",
         "  var v = foo();",
         "}",
@@ skipping 650 matching lines @@
             && index < sourceInfo.getEnd()
             && clazz.isInstance(node)) {
           result.set((T) node);
         }
         return super.visitNode(node);
       }
     });
     return result.get();
   }
 }