| OLD | NEW |
| (Empty) |
| 1 // This code was auto-generated, is not intended to be edited, and is subject to | |
| 2 // significant change. Please see the README file for more information. | |
| 3 | |
| 4 library engine.resolver_test; | |
| 5 | |
| 6 import 'dart:collection'; | |
| 7 import 'package:analyzer-experimental/src/generated/java_core.dart'; | |
| 8 import 'package:analyzer-experimental/src/generated/java_engine.dart'; | |
| 9 import 'package:analyzer-experimental/src/generated/java_junit.dart'; | |
| 10 import 'package:analyzer-experimental/src/generated/source_io.dart'; | |
| 11 import 'package:analyzer-experimental/src/generated/error.dart'; | |
| 12 import 'package:analyzer-experimental/src/generated/scanner.dart'; | |
| 13 import 'package:analyzer-experimental/src/generated/element.dart'; | |
| 14 import 'package:analyzer-experimental/src/generated/resolver.dart'; | |
| 15 import 'package:analyzer-experimental/src/generated/engine.dart'; | |
| 16 import 'package:analyzer-experimental/src/generated/java_engine_io.dart'; | |
| 17 import 'package:analyzer-experimental/src/generated/ast.dart' hide Annotation; | |
| 18 import 'package:analyzer-experimental/src/generated/sdk.dart' show DartSdk; | |
| 19 import 'package:unittest/unittest.dart' as _ut; | |
| 20 import 'test_support.dart'; | |
| 21 import 'ast_test.dart' show ASTFactory; | |
| 22 import 'element_test.dart' show ElementFactory; | |
| 23 | |
| 24 class LibraryTest extends EngineTestCase { | |
| 25 /** | |
| 26 * The error listener to which all errors will be reported. | |
| 27 */ | |
| 28 GatheringErrorListener _errorListener; | |
| 29 /** | |
| 30 * The source factory used to create libraries. | |
| 31 */ | |
| 32 SourceFactory _sourceFactory; | |
| 33 /** | |
| 34 * The analysis context to pass in to all libraries created by the tests. | |
| 35 */ | |
| 36 AnalysisContextImpl _analysisContext; | |
| 37 /** | |
| 38 * The library used by the tests. | |
| 39 */ | |
| 40 Library _library5; | |
| 41 void setUp() { | |
| 42 _sourceFactory = new SourceFactory.con2([new FileUriResolver()]); | |
| 43 _analysisContext = new AnalysisContextImpl(); | |
| 44 _analysisContext.sourceFactory = _sourceFactory; | |
| 45 _errorListener = new GatheringErrorListener(); | |
| 46 _library5 = library("/lib.dart"); | |
| 47 } | |
| 48 void test_addExport() { | |
| 49 Library exportLibrary = library("/exported.dart"); | |
| 50 _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), export
Library); | |
| 51 List<Library> exports3 = _library5.exports; | |
| 52 EngineTestCase.assertLength(1, exports3); | |
| 53 JUnitTestCase.assertSame(exportLibrary, exports3[0]); | |
| 54 _errorListener.assertNoErrors(); | |
| 55 } | |
| 56 void test_addImport() { | |
| 57 Library importLibrary = library("/imported.dart"); | |
| 58 _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []),
importLibrary); | |
| 59 List<Library> imports3 = _library5.imports; | |
| 60 EngineTestCase.assertLength(1, imports3); | |
| 61 JUnitTestCase.assertSame(importLibrary, imports3[0]); | |
| 62 _errorListener.assertNoErrors(); | |
| 63 } | |
| 64 void test_getExplicitlyImportsCore() { | |
| 65 JUnitTestCase.assertFalse(_library5.explicitlyImportsCore); | |
| 66 _errorListener.assertNoErrors(); | |
| 67 } | |
| 68 void test_getExport() { | |
| 69 ExportDirective directive = ASTFactory.exportDirective2("exported.dart", [])
; | |
| 70 Library exportLibrary = library("/exported.dart"); | |
| 71 _library5.addExport(directive, exportLibrary); | |
| 72 JUnitTestCase.assertSame(exportLibrary, _library5.getExport(directive)); | |
| 73 _errorListener.assertNoErrors(); | |
| 74 } | |
| 75 void test_getExports() { | |
| 76 EngineTestCase.assertLength(0, _library5.exports); | |
| 77 _errorListener.assertNoErrors(); | |
| 78 } | |
| 79 void test_getImport() { | |
| 80 ImportDirective directive = ASTFactory.importDirective2("imported.dart", nul
l, []); | |
| 81 Library importLibrary = library("/imported.dart"); | |
| 82 _library5.addImport(directive, importLibrary); | |
| 83 JUnitTestCase.assertSame(importLibrary, _library5.getImport(directive)); | |
| 84 _errorListener.assertNoErrors(); | |
| 85 } | |
| 86 void test_getImports() { | |
| 87 EngineTestCase.assertLength(0, _library5.imports); | |
| 88 _errorListener.assertNoErrors(); | |
| 89 } | |
| 90 void test_getImportsAndExports() { | |
| 91 _library5.addImport(ASTFactory.importDirective2("imported.dart", null, []),
library("/imported.dart")); | |
| 92 _library5.addExport(ASTFactory.exportDirective2("exported.dart", []), librar
y("/exported.dart")); | |
| 93 EngineTestCase.assertLength(2, _library5.importsAndExports); | |
| 94 _errorListener.assertNoErrors(); | |
| 95 } | |
| 96 void test_getLibraryScope() { | |
| 97 LibraryElementImpl element = new LibraryElementImpl(_analysisContext, ASTFac
tory.libraryIdentifier2(["lib"])); | |
| 98 element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart")
; | |
| 99 _library5.libraryElement = element; | |
| 100 JUnitTestCase.assertNotNull(_library5.libraryScope); | |
| 101 _errorListener.assertNoErrors(); | |
| 102 } | |
| 103 void test_getLibrarySource() { | |
| 104 JUnitTestCase.assertNotNull(_library5.librarySource); | |
| 105 } | |
| 106 void test_setExplicitlyImportsCore() { | |
| 107 _library5.explicitlyImportsCore = true; | |
| 108 JUnitTestCase.assertTrue(_library5.explicitlyImportsCore); | |
| 109 _errorListener.assertNoErrors(); | |
| 110 } | |
| 111 void test_setLibraryElement() { | |
| 112 LibraryElementImpl element = new LibraryElementImpl(_analysisContext, ASTFac
tory.libraryIdentifier2(["lib"])); | |
| 113 _library5.libraryElement = element; | |
| 114 JUnitTestCase.assertSame(element, _library5.libraryElement); | |
| 115 } | |
| 116 Library library(String definingCompilationUnitPath) => new Library(_analysisCo
ntext, _errorListener, new FileBasedSource.con1(_sourceFactory, FileUtilities2.c
reateFile(definingCompilationUnitPath))); | |
| 117 static dartSuite() { | |
| 118 _ut.group('LibraryTest', () { | |
| 119 _ut.test('test_addExport', () { | |
| 120 final __test = new LibraryTest(); | |
| 121 runJUnitTest(__test, __test.test_addExport); | |
| 122 }); | |
| 123 _ut.test('test_addImport', () { | |
| 124 final __test = new LibraryTest(); | |
| 125 runJUnitTest(__test, __test.test_addImport); | |
| 126 }); | |
| 127 _ut.test('test_getExplicitlyImportsCore', () { | |
| 128 final __test = new LibraryTest(); | |
| 129 runJUnitTest(__test, __test.test_getExplicitlyImportsCore); | |
| 130 }); | |
| 131 _ut.test('test_getExport', () { | |
| 132 final __test = new LibraryTest(); | |
| 133 runJUnitTest(__test, __test.test_getExport); | |
| 134 }); | |
| 135 _ut.test('test_getExports', () { | |
| 136 final __test = new LibraryTest(); | |
| 137 runJUnitTest(__test, __test.test_getExports); | |
| 138 }); | |
| 139 _ut.test('test_getImport', () { | |
| 140 final __test = new LibraryTest(); | |
| 141 runJUnitTest(__test, __test.test_getImport); | |
| 142 }); | |
| 143 _ut.test('test_getImports', () { | |
| 144 final __test = new LibraryTest(); | |
| 145 runJUnitTest(__test, __test.test_getImports); | |
| 146 }); | |
| 147 _ut.test('test_getImportsAndExports', () { | |
| 148 final __test = new LibraryTest(); | |
| 149 runJUnitTest(__test, __test.test_getImportsAndExports); | |
| 150 }); | |
| 151 _ut.test('test_getLibraryScope', () { | |
| 152 final __test = new LibraryTest(); | |
| 153 runJUnitTest(__test, __test.test_getLibraryScope); | |
| 154 }); | |
| 155 _ut.test('test_getLibrarySource', () { | |
| 156 final __test = new LibraryTest(); | |
| 157 runJUnitTest(__test, __test.test_getLibrarySource); | |
| 158 }); | |
| 159 _ut.test('test_setExplicitlyImportsCore', () { | |
| 160 final __test = new LibraryTest(); | |
| 161 runJUnitTest(__test, __test.test_setExplicitlyImportsCore); | |
| 162 }); | |
| 163 _ut.test('test_setLibraryElement', () { | |
| 164 final __test = new LibraryTest(); | |
| 165 runJUnitTest(__test, __test.test_setLibraryElement); | |
| 166 }); | |
| 167 }); | |
| 168 } | |
| 169 } | |
| 170 class StaticTypeWarningCodeTest extends ResolverTestCase { | |
| 171 void fail_inaccessibleSetter() { | |
| 172 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 173 resolve(source, []); | |
| 174 assertErrors([StaticTypeWarningCode.INACCESSIBLE_SETTER]); | |
| 175 verify([source]); | |
| 176 } | |
| 177 void fail_inconsistentMethodInheritance() { | |
| 178 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 179 resolve(source, []); | |
| 180 assertErrors([StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]); | |
| 181 verify([source]); | |
| 182 } | |
| 183 void fail_nonTypeAsTypeArgument() { | |
| 184 Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;
", "class B<E> {}", "f(B<A> b) {}"])); | |
| 185 resolve(source, []); | |
| 186 assertErrors([StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]); | |
| 187 verify([source]); | |
| 188 } | |
| 189 void fail_redirectWithInvalidTypeParameters() { | |
| 190 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 191 resolve(source, []); | |
| 192 assertErrors([StaticTypeWarningCode.REDIRECT_WITH_INVALID_TYPE_PARAMETERS]); | |
| 193 verify([source]); | |
| 194 } | |
| 195 void fail_typeArgumentViolatesBounds() { | |
| 196 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 197 resolve(source, []); | |
| 198 assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_VIOLATES_BOUNDS]); | |
| 199 verify([source]); | |
| 200 } | |
| 201 void test_invalidAssignment_instanceVariable() { | |
| 202 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", "}", "f() {", " A a;", " a.x = '0';", "}"])); | |
| 203 resolve(source, []); | |
| 204 assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]); | |
| 205 verify([source]); | |
| 206 } | |
| 207 void test_invalidAssignment_localVariable() { | |
| 208 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " int x;", " x = '0';", "}"])); | |
| 209 resolve(source, []); | |
| 210 assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]); | |
| 211 verify([source]); | |
| 212 } | |
| 213 void test_invalidAssignment_staticVariable() { | |
| 214 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static int x;", "}", "f() {", " A.x = '0';", "}"])); | |
| 215 resolve(source, []); | |
| 216 assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]); | |
| 217 verify([source]); | |
| 218 } | |
| 219 void test_invocationOfNonFunction_class() { | |
| 220 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " void m() {", " A();", " }", "}"])); | |
| 221 resolve(source, []); | |
| 222 assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]); | |
| 223 verify([source]); | |
| 224 } | |
| 225 void test_invocationOfNonFunction_localVariable() { | |
| 226 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " int x;", " return x();", "}"])); | |
| 227 resolve(source, []); | |
| 228 assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]); | |
| 229 verify([source]); | |
| 230 } | |
| 231 void test_invocationOfNonFunction_ordinaryInvocation() { | |
| 232 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", "}", "class B {", " m() {", " A.x();", " }", "}"])); | |
| 233 resolve(source, []); | |
| 234 assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]); | |
| 235 } | |
| 236 void test_invocationOfNonFunction_staticInvocation() { | |
| 237 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static int get g => 0;", " f() {", " A.g();", " }", "}"])); | |
| 238 resolve(source, []); | |
| 239 assertErrors([StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]); | |
| 240 } | |
| 241 void test_nonBoolCondition_conditional() { | |
| 242 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {
return 3 ? 2 : 1; }"])); | |
| 243 resolve(source, []); | |
| 244 assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]); | |
| 245 verify([source]); | |
| 246 } | |
| 247 void test_nonBoolCondition_do() { | |
| 248 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " do {} while (3);", "}"])); | |
| 249 resolve(source, []); | |
| 250 assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]); | |
| 251 verify([source]); | |
| 252 } | |
| 253 void test_nonBoolCondition_if() { | |
| 254 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " if (3) return 2; else return 1;", "}"])); | |
| 255 resolve(source, []); | |
| 256 assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]); | |
| 257 verify([source]); | |
| 258 } | |
| 259 void test_nonBoolCondition_while() { | |
| 260 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " while (3) {}", "}"])); | |
| 261 resolve(source, []); | |
| 262 assertErrors([StaticTypeWarningCode.NON_BOOL_CONDITION]); | |
| 263 verify([source]); | |
| 264 } | |
| 265 void test_nonBoolExpression() { | |
| 266 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " assert(0);", "}"])); | |
| 267 resolve(source, []); | |
| 268 assertErrors([StaticTypeWarningCode.NON_BOOL_EXPRESSION]); | |
| 269 verify([source]); | |
| 270 } | |
| 271 void test_returnOfInvalidType_function() { | |
| 272 Source source = addSource("/test.dart", EngineTestCase.createSource(["int f(
) { return '0'; }"])); | |
| 273 resolve(source, []); | |
| 274 assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]); | |
| 275 verify([source]); | |
| 276 } | |
| 277 void test_returnOfInvalidType_localFunction() { | |
| 278 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " String m() {", " int f() { return '0'; }", " }", "}"])); | |
| 279 resolve(source, []); | |
| 280 assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]); | |
| 281 verify([source]); | |
| 282 } | |
| 283 void test_returnOfInvalidType_method() { | |
| 284 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int f() { return '0'; }", "}"])); | |
| 285 resolve(source, []); | |
| 286 assertErrors([StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]); | |
| 287 verify([source]); | |
| 288 } | |
| 289 void test_typeArgumentNotMatchingBounds_const() { | |
| 290 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B {}", "class G<E extends A> {", " const G() {}", "}", "f() { ret
urn const G<B>(); }"])); | |
| 291 resolve(source, []); | |
| 292 assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]); | |
| 293 verify([source]); | |
| 294 } | |
| 295 void test_typeArgumentNotMatchingBounds_new() { | |
| 296 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B {}", "class G<E extends A> {}", "f() { return new G<B>(); }"])); | |
| 297 resolve(source, []); | |
| 298 assertErrors([StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]); | |
| 299 verify([source]); | |
| 300 } | |
| 301 void test_undefinedGetter() { | |
| 302 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
T {}", "f(T e) { return e.m; }"])); | |
| 303 resolve(source, []); | |
| 304 assertErrors([StaticTypeWarningCode.UNDEFINED_GETTER]); | |
| 305 } | |
| 306 void test_undefinedGetter_static() { | |
| 307 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "var a = A.B;"])); | |
| 308 resolve(source, []); | |
| 309 assertErrors([StaticTypeWarningCode.UNDEFINED_GETTER]); | |
| 310 } | |
| 311 void test_undefinedSetter() { | |
| 312 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
T {}", "f(T e1) { e1.m = 0; }"])); | |
| 313 resolve(source, []); | |
| 314 assertErrors([StaticTypeWarningCode.UNDEFINED_SETTER]); | |
| 315 } | |
| 316 void test_undefinedSetter_static() { | |
| 317 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "f() { A.B = 0;}"])); | |
| 318 resolve(source, []); | |
| 319 assertErrors([StaticTypeWarningCode.UNDEFINED_SETTER]); | |
| 320 } | |
| 321 void test_undefinedSuperMethod() { | |
| 322 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {", " m() { return super.m(); }", "}"])); | |
| 323 resolve(source, []); | |
| 324 assertErrors([StaticTypeWarningCode.UNDEFINED_SUPER_METHOD]); | |
| 325 verify([source]); | |
| 326 } | |
| 327 void test_wrongNumberOfTypeArguments_tooFew() { | |
| 328 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A<E, F> {}", "A<A> a = null;"])); | |
| 329 resolve(source, []); | |
| 330 assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 331 verify([source]); | |
| 332 } | |
| 333 void test_wrongNumberOfTypeArguments_tooMany() { | |
| 334 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A<E> {}", "A<A, A> a = null;"])); | |
| 335 resolve(source, []); | |
| 336 assertErrors([StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 337 verify([source]); | |
| 338 } | |
| 339 static dartSuite() { | |
| 340 _ut.group('StaticTypeWarningCodeTest', () { | |
| 341 _ut.test('test_invalidAssignment_instanceVariable', () { | |
| 342 final __test = new StaticTypeWarningCodeTest(); | |
| 343 runJUnitTest(__test, __test.test_invalidAssignment_instanceVariable); | |
| 344 }); | |
| 345 _ut.test('test_invalidAssignment_localVariable', () { | |
| 346 final __test = new StaticTypeWarningCodeTest(); | |
| 347 runJUnitTest(__test, __test.test_invalidAssignment_localVariable); | |
| 348 }); | |
| 349 _ut.test('test_invalidAssignment_staticVariable', () { | |
| 350 final __test = new StaticTypeWarningCodeTest(); | |
| 351 runJUnitTest(__test, __test.test_invalidAssignment_staticVariable); | |
| 352 }); | |
| 353 _ut.test('test_invocationOfNonFunction_class', () { | |
| 354 final __test = new StaticTypeWarningCodeTest(); | |
| 355 runJUnitTest(__test, __test.test_invocationOfNonFunction_class); | |
| 356 }); | |
| 357 _ut.test('test_invocationOfNonFunction_localVariable', () { | |
| 358 final __test = new StaticTypeWarningCodeTest(); | |
| 359 runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable); | |
| 360 }); | |
| 361 _ut.test('test_invocationOfNonFunction_ordinaryInvocation', () { | |
| 362 final __test = new StaticTypeWarningCodeTest(); | |
| 363 runJUnitTest(__test, __test.test_invocationOfNonFunction_ordinaryInvocat
ion); | |
| 364 }); | |
| 365 _ut.test('test_invocationOfNonFunction_staticInvocation', () { | |
| 366 final __test = new StaticTypeWarningCodeTest(); | |
| 367 runJUnitTest(__test, __test.test_invocationOfNonFunction_staticInvocatio
n); | |
| 368 }); | |
| 369 _ut.test('test_nonBoolCondition_conditional', () { | |
| 370 final __test = new StaticTypeWarningCodeTest(); | |
| 371 runJUnitTest(__test, __test.test_nonBoolCondition_conditional); | |
| 372 }); | |
| 373 _ut.test('test_nonBoolCondition_do', () { | |
| 374 final __test = new StaticTypeWarningCodeTest(); | |
| 375 runJUnitTest(__test, __test.test_nonBoolCondition_do); | |
| 376 }); | |
| 377 _ut.test('test_nonBoolCondition_if', () { | |
| 378 final __test = new StaticTypeWarningCodeTest(); | |
| 379 runJUnitTest(__test, __test.test_nonBoolCondition_if); | |
| 380 }); | |
| 381 _ut.test('test_nonBoolCondition_while', () { | |
| 382 final __test = new StaticTypeWarningCodeTest(); | |
| 383 runJUnitTest(__test, __test.test_nonBoolCondition_while); | |
| 384 }); | |
| 385 _ut.test('test_nonBoolExpression', () { | |
| 386 final __test = new StaticTypeWarningCodeTest(); | |
| 387 runJUnitTest(__test, __test.test_nonBoolExpression); | |
| 388 }); | |
| 389 _ut.test('test_returnOfInvalidType_function', () { | |
| 390 final __test = new StaticTypeWarningCodeTest(); | |
| 391 runJUnitTest(__test, __test.test_returnOfInvalidType_function); | |
| 392 }); | |
| 393 _ut.test('test_returnOfInvalidType_localFunction', () { | |
| 394 final __test = new StaticTypeWarningCodeTest(); | |
| 395 runJUnitTest(__test, __test.test_returnOfInvalidType_localFunction); | |
| 396 }); | |
| 397 _ut.test('test_returnOfInvalidType_method', () { | |
| 398 final __test = new StaticTypeWarningCodeTest(); | |
| 399 runJUnitTest(__test, __test.test_returnOfInvalidType_method); | |
| 400 }); | |
| 401 _ut.test('test_typeArgumentNotMatchingBounds_const', () { | |
| 402 final __test = new StaticTypeWarningCodeTest(); | |
| 403 runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const); | |
| 404 }); | |
| 405 _ut.test('test_typeArgumentNotMatchingBounds_new', () { | |
| 406 final __test = new StaticTypeWarningCodeTest(); | |
| 407 runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new); | |
| 408 }); | |
| 409 _ut.test('test_undefinedGetter', () { | |
| 410 final __test = new StaticTypeWarningCodeTest(); | |
| 411 runJUnitTest(__test, __test.test_undefinedGetter); | |
| 412 }); | |
| 413 _ut.test('test_undefinedGetter_static', () { | |
| 414 final __test = new StaticTypeWarningCodeTest(); | |
| 415 runJUnitTest(__test, __test.test_undefinedGetter_static); | |
| 416 }); | |
| 417 _ut.test('test_undefinedSetter', () { | |
| 418 final __test = new StaticTypeWarningCodeTest(); | |
| 419 runJUnitTest(__test, __test.test_undefinedSetter); | |
| 420 }); | |
| 421 _ut.test('test_undefinedSetter_static', () { | |
| 422 final __test = new StaticTypeWarningCodeTest(); | |
| 423 runJUnitTest(__test, __test.test_undefinedSetter_static); | |
| 424 }); | |
| 425 _ut.test('test_undefinedSuperMethod', () { | |
| 426 final __test = new StaticTypeWarningCodeTest(); | |
| 427 runJUnitTest(__test, __test.test_undefinedSuperMethod); | |
| 428 }); | |
| 429 _ut.test('test_wrongNumberOfTypeArguments_tooFew', () { | |
| 430 final __test = new StaticTypeWarningCodeTest(); | |
| 431 runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_tooFew); | |
| 432 }); | |
| 433 _ut.test('test_wrongNumberOfTypeArguments_tooMany', () { | |
| 434 final __test = new StaticTypeWarningCodeTest(); | |
| 435 runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_tooMany); | |
| 436 }); | |
| 437 }); | |
| 438 } | |
| 439 } | |
| 440 class TypeResolverVisitorTest extends EngineTestCase { | |
| 441 /** | |
| 442 * The error listener to which errors will be reported. | |
| 443 */ | |
| 444 GatheringErrorListener _listener; | |
| 445 /** | |
| 446 * The object representing the information about the library in which the type
s are being | |
| 447 * resolved. | |
| 448 */ | |
| 449 Library _library; | |
| 450 /** | |
| 451 * The type provider used to access the types. | |
| 452 */ | |
| 453 TestTypeProvider _typeProvider; | |
| 454 /** | |
| 455 * The visitor used to resolve types needed to form the type hierarchy. | |
| 456 */ | |
| 457 TypeResolverVisitor _visitor; | |
| 458 void fail_visitConstructorDeclaration() { | |
| 459 JUnitTestCase.fail("Not yet tested"); | |
| 460 _listener.assertNoErrors(); | |
| 461 } | |
| 462 void fail_visitFieldFormalParameter_noType() { | |
| 463 FormalParameter node = ASTFactory.fieldFormalParameter(Keyword.VAR, null, "p
"); | |
| 464 JUnitTestCase.assertSame(_typeProvider.dynamicType, resolve5(node, [])); | |
| 465 _listener.assertNoErrors(); | |
| 466 } | |
| 467 void fail_visitFieldFormalParameter_type() { | |
| 468 FormalParameter node = ASTFactory.fieldFormalParameter(null, ASTFactory.type
Name3("int", []), "p"); | |
| 469 JUnitTestCase.assertSame(_typeProvider.intType, resolve5(node, [])); | |
| 470 _listener.assertNoErrors(); | |
| 471 } | |
| 472 void fail_visitFunctionDeclaration() { | |
| 473 JUnitTestCase.fail("Not yet tested"); | |
| 474 _listener.assertNoErrors(); | |
| 475 } | |
| 476 void fail_visitFunctionTypeAlias() { | |
| 477 JUnitTestCase.fail("Not yet tested"); | |
| 478 _listener.assertNoErrors(); | |
| 479 } | |
| 480 void fail_visitFunctionTypedFormalParameter() { | |
| 481 JUnitTestCase.fail("Not yet tested"); | |
| 482 _listener.assertNoErrors(); | |
| 483 } | |
| 484 void fail_visitMethodDeclaration() { | |
| 485 JUnitTestCase.fail("Not yet tested"); | |
| 486 _listener.assertNoErrors(); | |
| 487 } | |
| 488 void fail_visitVariableDeclaration() { | |
| 489 JUnitTestCase.fail("Not yet tested"); | |
| 490 ClassElement type = ElementFactory.classElement2("A", []); | |
| 491 VariableDeclaration node = ASTFactory.variableDeclaration("a"); | |
| 492 ASTFactory.variableDeclarationList(null, ASTFactory.typeName(type, []), [nod
e]); | |
| 493 JUnitTestCase.assertSame(type.type, node.name.staticType); | |
| 494 _listener.assertNoErrors(); | |
| 495 } | |
| 496 void setUp() { | |
| 497 _listener = new GatheringErrorListener(); | |
| 498 SourceFactory factory = new SourceFactory.con2([new FileUriResolver()]); | |
| 499 AnalysisContextImpl context = new AnalysisContextImpl(); | |
| 500 context.sourceFactory = factory; | |
| 501 Source librarySource = new FileBasedSource.con1(factory, FileUtilities2.crea
teFile("/lib.dart")); | |
| 502 _library = new Library(context, _listener, librarySource); | |
| 503 LibraryElementImpl element = new LibraryElementImpl(context, ASTFactory.libr
aryIdentifier2(["lib"])); | |
| 504 element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart")
; | |
| 505 _library.libraryElement = element; | |
| 506 _typeProvider = new TestTypeProvider(); | |
| 507 _visitor = new TypeResolverVisitor(_library, librarySource, _typeProvider); | |
| 508 } | |
| 509 void test_visitCatchClause_exception() { | |
| 510 CatchClause clause = ASTFactory.catchClause("e", []); | |
| 511 resolve(clause, _typeProvider.objectType, null, []); | |
| 512 _listener.assertNoErrors(); | |
| 513 } | |
| 514 void test_visitCatchClause_exception_stackTrace() { | |
| 515 CatchClause clause = ASTFactory.catchClause2("e", "s", []); | |
| 516 resolve(clause, _typeProvider.objectType, _typeProvider.stackTraceType, []); | |
| 517 _listener.assertNoErrors(); | |
| 518 } | |
| 519 void test_visitCatchClause_on_exception() { | |
| 520 ClassElement exceptionElement = ElementFactory.classElement2("E", []); | |
| 521 TypeName exceptionType = ASTFactory.typeName(exceptionElement, []); | |
| 522 CatchClause clause = ASTFactory.catchClause4(exceptionType, "e", []); | |
| 523 resolve(clause, exceptionElement.type, null, [exceptionElement]); | |
| 524 _listener.assertNoErrors(); | |
| 525 } | |
| 526 void test_visitCatchClause_on_exception_stackTrace() { | |
| 527 ClassElement exceptionElement = ElementFactory.classElement2("E", []); | |
| 528 TypeName exceptionType = ASTFactory.typeName(exceptionElement, []); | |
| 529 ((exceptionType.name as SimpleIdentifier)).element = exceptionElement; | |
| 530 CatchClause clause = ASTFactory.catchClause5(exceptionType, "e", "s", []); | |
| 531 resolve(clause, exceptionElement.type, _typeProvider.stackTraceType, [except
ionElement]); | |
| 532 _listener.assertNoErrors(); | |
| 533 } | |
| 534 void test_visitClassDeclaration() { | |
| 535 ClassElement elementA = ElementFactory.classElement2("A", []); | |
| 536 ClassElement elementB = ElementFactory.classElement2("B", []); | |
| 537 ClassElement elementC = ElementFactory.classElement2("C", []); | |
| 538 ClassElement elementD = ElementFactory.classElement2("D", []); | |
| 539 ExtendsClause extendsClause2 = ASTFactory.extendsClause(ASTFactory.typeName(
elementB, [])); | |
| 540 WithClause withClause2 = ASTFactory.withClause([ASTFactory.typeName(elementC
, [])]); | |
| 541 ImplementsClause implementsClause2 = ASTFactory.implementsClause([ASTFactory
.typeName(elementD, [])]); | |
| 542 ClassDeclaration declaration = ASTFactory.classDeclaration(null, "A", null,
extendsClause2, withClause2, implementsClause2, []); | |
| 543 declaration.name.element = elementA; | |
| 544 resolveNode(declaration, [elementA, elementB, elementC, elementD]); | |
| 545 JUnitTestCase.assertSame(elementB.type, elementA.supertype); | |
| 546 List<InterfaceType> mixins3 = elementA.mixins; | |
| 547 EngineTestCase.assertLength(1, mixins3); | |
| 548 JUnitTestCase.assertSame(elementC.type, mixins3[0]); | |
| 549 List<InterfaceType> interfaces3 = elementA.interfaces; | |
| 550 EngineTestCase.assertLength(1, interfaces3); | |
| 551 JUnitTestCase.assertSame(elementD.type, interfaces3[0]); | |
| 552 _listener.assertNoErrors(); | |
| 553 } | |
| 554 void test_visitClassTypeAlias() { | |
| 555 ClassElement elementA = ElementFactory.classElement2("A", []); | |
| 556 ClassElement elementB = ElementFactory.classElement2("B", []); | |
| 557 ClassElement elementC = ElementFactory.classElement2("C", []); | |
| 558 ClassElement elementD = ElementFactory.classElement2("D", []); | |
| 559 WithClause withClause3 = ASTFactory.withClause([ASTFactory.typeName(elementC
, [])]); | |
| 560 ImplementsClause implementsClause3 = ASTFactory.implementsClause([ASTFactory
.typeName(elementD, [])]); | |
| 561 ClassTypeAlias alias = ASTFactory.classTypeAlias("A", null, null, ASTFactory
.typeName(elementB, []), withClause3, implementsClause3); | |
| 562 alias.name.element = elementA; | |
| 563 resolveNode(alias, [elementA, elementB, elementC, elementD]); | |
| 564 JUnitTestCase.assertSame(elementB.type, elementA.supertype); | |
| 565 List<InterfaceType> mixins4 = elementA.mixins; | |
| 566 EngineTestCase.assertLength(1, mixins4); | |
| 567 JUnitTestCase.assertSame(elementC.type, mixins4[0]); | |
| 568 List<InterfaceType> interfaces4 = elementA.interfaces; | |
| 569 EngineTestCase.assertLength(1, interfaces4); | |
| 570 JUnitTestCase.assertSame(elementD.type, interfaces4[0]); | |
| 571 _listener.assertNoErrors(); | |
| 572 } | |
| 573 void test_visitSimpleFormalParameter_noType() { | |
| 574 FormalParameter node = ASTFactory.simpleFormalParameter3("p"); | |
| 575 node.identifier.element = new ParameterElementImpl(ASTFactory.identifier2("p
")); | |
| 576 JUnitTestCase.assertSame(_typeProvider.dynamicType, resolve5(node, [])); | |
| 577 _listener.assertNoErrors(); | |
| 578 } | |
| 579 void test_visitSimpleFormalParameter_type() { | |
| 580 InterfaceType intType8 = _typeProvider.intType; | |
| 581 ClassElement intElement = intType8.element; | |
| 582 FormalParameter node = ASTFactory.simpleFormalParameter4(ASTFactory.typeName
(intElement, []), "p"); | |
| 583 SimpleIdentifier identifier18 = node.identifier; | |
| 584 ParameterElementImpl element = new ParameterElementImpl(identifier18); | |
| 585 identifier18.element = element; | |
| 586 JUnitTestCase.assertSame(intType8, resolve5(node, [intElement])); | |
| 587 _listener.assertNoErrors(); | |
| 588 } | |
| 589 void test_visitTypeName_noParameters_noArguments() { | |
| 590 ClassElement classA = ElementFactory.classElement2("A", []); | |
| 591 TypeName typeName5 = ASTFactory.typeName(classA, []); | |
| 592 typeName5.type = null; | |
| 593 resolveNode(typeName5, [classA]); | |
| 594 JUnitTestCase.assertSame(classA.type, typeName5.type); | |
| 595 _listener.assertNoErrors(); | |
| 596 } | |
| 597 void test_visitTypeName_parameters_arguments() { | |
| 598 ClassElement classA = ElementFactory.classElement2("A", ["E"]); | |
| 599 ClassElement classB = ElementFactory.classElement2("B", []); | |
| 600 TypeName typeName6 = ASTFactory.typeName(classA, [ASTFactory.typeName(classB
, [])]); | |
| 601 typeName6.type = null; | |
| 602 resolveNode(typeName6, [classA, classB]); | |
| 603 InterfaceType resultType = typeName6.type as InterfaceType; | |
| 604 JUnitTestCase.assertSame(classA, resultType.element); | |
| 605 List<Type2> resultArguments = resultType.typeArguments; | |
| 606 EngineTestCase.assertLength(1, resultArguments); | |
| 607 JUnitTestCase.assertSame(classB.type, resultArguments[0]); | |
| 608 _listener.assertNoErrors(); | |
| 609 } | |
| 610 void test_visitTypeName_parameters_noArguments() { | |
| 611 ClassElement classA = ElementFactory.classElement2("A", ["E"]); | |
| 612 TypeName typeName7 = ASTFactory.typeName(classA, []); | |
| 613 typeName7.type = null; | |
| 614 resolveNode(typeName7, [classA]); | |
| 615 InterfaceType resultType = typeName7.type as InterfaceType; | |
| 616 JUnitTestCase.assertSame(classA, resultType.element); | |
| 617 List<Type2> resultArguments = resultType.typeArguments; | |
| 618 EngineTestCase.assertLength(1, resultArguments); | |
| 619 JUnitTestCase.assertSame(DynamicTypeImpl.instance, resultArguments[0]); | |
| 620 _listener.assertNoErrors(); | |
| 621 } | |
| 622 /** | |
| 623 * Analyze the given catch clause and assert that the types of the parameters
have been set to the | |
| 624 * given types. The types can be null if the catch clause does not have the co
rresponding | |
| 625 * parameter. | |
| 626 * @param node the catch clause to be analyzed | |
| 627 * @param exceptionType the expected type of the exception parameter | |
| 628 * @param stackTraceType the expected type of the stack trace parameter | |
| 629 * @param definedElements the elements that are to be defined in the scope in
which the element is | |
| 630 * being resolved | |
| 631 */ | |
| 632 void resolve(CatchClause node, InterfaceType exceptionType, InterfaceType stac
kTraceType, List<Element> definedElements) { | |
| 633 resolveNode(node, definedElements); | |
| 634 SimpleIdentifier exceptionParameter3 = node.exceptionParameter; | |
| 635 if (exceptionParameter3 != null) { | |
| 636 JUnitTestCase.assertSame(exceptionType, exceptionParameter3.staticType); | |
| 637 } | |
| 638 SimpleIdentifier stackTraceParameter3 = node.stackTraceParameter; | |
| 639 if (stackTraceParameter3 != null) { | |
| 640 JUnitTestCase.assertSame(stackTraceType, stackTraceParameter3.staticType); | |
| 641 } | |
| 642 } | |
| 643 /** | |
| 644 * Return the type associated with the given parameter after the static type a
nalyzer has computed | |
| 645 * a type for it. | |
| 646 * @param node the parameter with which the type is associated | |
| 647 * @param definedElements the elements that are to be defined in the scope in
which the element is | |
| 648 * being resolved | |
| 649 * @return the type associated with the parameter | |
| 650 */ | |
| 651 Type2 resolve5(FormalParameter node, List<Element> definedElements) { | |
| 652 resolveNode(node, definedElements); | |
| 653 return ((node.identifier.element as ParameterElement)).type; | |
| 654 } | |
| 655 /** | |
| 656 * Return the element associated with the given identifier after the resolver
has resolved the | |
| 657 * identifier. | |
| 658 * @param node the expression to be resolved | |
| 659 * @param definedElements the elements that are to be defined in the scope in
which the element is | |
| 660 * being resolved | |
| 661 * @return the element to which the expression was resolved | |
| 662 */ | |
| 663 void resolveNode(ASTNode node, List<Element> definedElements) { | |
| 664 for (Element element in definedElements) { | |
| 665 _library.libraryScope.define(element); | |
| 666 } | |
| 667 node.accept(_visitor); | |
| 668 } | |
| 669 static dartSuite() { | |
| 670 _ut.group('TypeResolverVisitorTest', () { | |
| 671 _ut.test('test_visitCatchClause_exception', () { | |
| 672 final __test = new TypeResolverVisitorTest(); | |
| 673 runJUnitTest(__test, __test.test_visitCatchClause_exception); | |
| 674 }); | |
| 675 _ut.test('test_visitCatchClause_exception_stackTrace', () { | |
| 676 final __test = new TypeResolverVisitorTest(); | |
| 677 runJUnitTest(__test, __test.test_visitCatchClause_exception_stackTrace); | |
| 678 }); | |
| 679 _ut.test('test_visitCatchClause_on_exception', () { | |
| 680 final __test = new TypeResolverVisitorTest(); | |
| 681 runJUnitTest(__test, __test.test_visitCatchClause_on_exception); | |
| 682 }); | |
| 683 _ut.test('test_visitCatchClause_on_exception_stackTrace', () { | |
| 684 final __test = new TypeResolverVisitorTest(); | |
| 685 runJUnitTest(__test, __test.test_visitCatchClause_on_exception_stackTrac
e); | |
| 686 }); | |
| 687 _ut.test('test_visitClassDeclaration', () { | |
| 688 final __test = new TypeResolverVisitorTest(); | |
| 689 runJUnitTest(__test, __test.test_visitClassDeclaration); | |
| 690 }); | |
| 691 _ut.test('test_visitClassTypeAlias', () { | |
| 692 final __test = new TypeResolverVisitorTest(); | |
| 693 runJUnitTest(__test, __test.test_visitClassTypeAlias); | |
| 694 }); | |
| 695 _ut.test('test_visitSimpleFormalParameter_noType', () { | |
| 696 final __test = new TypeResolverVisitorTest(); | |
| 697 runJUnitTest(__test, __test.test_visitSimpleFormalParameter_noType); | |
| 698 }); | |
| 699 _ut.test('test_visitSimpleFormalParameter_type', () { | |
| 700 final __test = new TypeResolverVisitorTest(); | |
| 701 runJUnitTest(__test, __test.test_visitSimpleFormalParameter_type); | |
| 702 }); | |
| 703 _ut.test('test_visitTypeName_noParameters_noArguments', () { | |
| 704 final __test = new TypeResolverVisitorTest(); | |
| 705 runJUnitTest(__test, __test.test_visitTypeName_noParameters_noArguments)
; | |
| 706 }); | |
| 707 _ut.test('test_visitTypeName_parameters_arguments', () { | |
| 708 final __test = new TypeResolverVisitorTest(); | |
| 709 runJUnitTest(__test, __test.test_visitTypeName_parameters_arguments); | |
| 710 }); | |
| 711 _ut.test('test_visitTypeName_parameters_noArguments', () { | |
| 712 final __test = new TypeResolverVisitorTest(); | |
| 713 runJUnitTest(__test, __test.test_visitTypeName_parameters_noArguments); | |
| 714 }); | |
| 715 }); | |
| 716 } | |
| 717 } | |
| 718 class ResolverTestCase extends EngineTestCase { | |
| 719 /** | |
| 720 * The source factory used to create {@link Source sources}. | |
| 721 */ | |
| 722 SourceFactory _sourceFactory; | |
| 723 /** | |
| 724 * The error listener used during resolution. | |
| 725 */ | |
| 726 GatheringErrorListener _errorListener; | |
| 727 /** | |
| 728 * The analysis context used to parse the compilation units being resolved. | |
| 729 */ | |
| 730 AnalysisContextImpl _analysisContext; | |
| 731 /** | |
| 732 * Assert that the number of errors that have been gathered matches the number
of errors that are | |
| 733 * given and that they have the expected error codes. The order in which the e
rrors were gathered | |
| 734 * is ignored. | |
| 735 * @param expectedErrorCodes the error codes of the errors that should have be
en gathered | |
| 736 * @throws AssertionFailedError if a different number of errors have been gath
ered than were | |
| 737 * expected | |
| 738 */ | |
| 739 void assertErrors(List<ErrorCode> expectedErrorCodes) { | |
| 740 _errorListener.assertErrors2(expectedErrorCodes); | |
| 741 } | |
| 742 void setUp() { | |
| 743 _errorListener = new GatheringErrorListener(); | |
| 744 _analysisContext = AnalysisContextFactory.contextWithCore(); | |
| 745 _sourceFactory = _analysisContext.sourceFactory; | |
| 746 } | |
| 747 /** | |
| 748 * Add a source file to the content provider. The file path should be absolute
. | |
| 749 * @param filePath the path of the file being added | |
| 750 * @param contents the contents to be returned by the content provider for the
specified file | |
| 751 * @return the source object representing the added file | |
| 752 */ | |
| 753 Source addSource(String filePath, String contents) { | |
| 754 Source source = new FileBasedSource.con1(_sourceFactory, FileUtilities2.crea
teFile(filePath)); | |
| 755 _sourceFactory.setContents(source, contents); | |
| 756 return source; | |
| 757 } | |
| 758 /** | |
| 759 * Assert that no errors have been gathered. | |
| 760 * @throws AssertionFailedError if any errors have been gathered | |
| 761 */ | |
| 762 void assertNoErrors() { | |
| 763 _errorListener.assertNoErrors(); | |
| 764 } | |
| 765 /** | |
| 766 * Create a library element that represents a library named {@code "test"} con
taining a single | |
| 767 * empty compilation unit. | |
| 768 * @return the library element that was created | |
| 769 */ | |
| 770 LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisConte
xtImpl(), "test", []); | |
| 771 /** | |
| 772 * Create a library element that represents a library with the given name cont
aining a single | |
| 773 * empty compilation unit. | |
| 774 * @param libraryName the name of the library to be created | |
| 775 * @return the library element that was created | |
| 776 */ | |
| 777 LibraryElementImpl createTestLibrary2(AnalysisContext context, String libraryN
ame, List<String> typeNames) { | |
| 778 int count = typeNames.length; | |
| 779 List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<Compilat
ionUnitElementImpl>(count); | |
| 780 for (int i = 0; i < count; i++) { | |
| 781 String typeName = typeNames[i]; | |
| 782 ClassElementImpl type = new ClassElementImpl(ASTFactory.identifier2(typeNa
me)); | |
| 783 String fileName = "${typeName}.dart"; | |
| 784 CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImp
l(fileName); | |
| 785 compilationUnit.source = new FileBasedSource.con1(_sourceFactory, FileUtil
ities2.createFile(fileName)); | |
| 786 compilationUnit.types = <ClassElement> [type]; | |
| 787 sourcedCompilationUnits[i] = compilationUnit; | |
| 788 } | |
| 789 String fileName = "${libraryName}.dart"; | |
| 790 CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(
fileName); | |
| 791 compilationUnit.source = new FileBasedSource.con1(_sourceFactory, FileUtilit
ies2.createFile(fileName)); | |
| 792 LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libr
aryIdentifier2([libraryName])); | |
| 793 library.definingCompilationUnit = compilationUnit; | |
| 794 library.parts = sourcedCompilationUnits; | |
| 795 return library; | |
| 796 } | |
| 797 AnalysisContext get analysisContext => _analysisContext; | |
| 798 GatheringErrorListener get errorListener => _errorListener; | |
| 799 SourceFactory get sourceFactory => _sourceFactory; | |
| 800 /** | |
| 801 * Given a library and all of its parts, resolve the contents of the library a
nd the contents of | |
| 802 * the parts. This assumes that the sources for the library and its parts have
already been added | |
| 803 * to the content provider using the method {@link #addSource(String,String)}. | |
| 804 * @param librarySource the source for the compilation unit that defines the l
ibrary | |
| 805 * @param unitSources the sources for the compilation units that are part of t
he library | |
| 806 * @return the element representing the resolved library | |
| 807 * @throws AnalysisException if the analysis could not be performed | |
| 808 */ | |
| 809 LibraryElement resolve(Source librarySource, List<Source> unitSources) { | |
| 810 LibraryResolver resolver = new LibraryResolver.con2(_analysisContext, _error
Listener); | |
| 811 return resolver.resolveLibrary(librarySource, true); | |
| 812 } | |
| 813 /** | |
| 814 * Verify that all of the identifiers in the compilation units associated with
the given sources | |
| 815 * have been resolved. | |
| 816 * @param resolvedElementMap a table mapping the AST nodes that have been reso
lved to the element | |
| 817 * to which they were resolved | |
| 818 * @param sources the sources identifying the compilation units to be verified | |
| 819 * @throws Exception if the contents of the compilation unit cannot be accesse
d | |
| 820 */ | |
| 821 void verify(List<Source> sources) { | |
| 822 ResolutionVerifier verifier = new ResolutionVerifier(); | |
| 823 for (Source source in sources) { | |
| 824 _analysisContext.parse3(source, _errorListener).accept(verifier); | |
| 825 } | |
| 826 verifier.assertResolved(); | |
| 827 } | |
| 828 static dartSuite() { | |
| 829 _ut.group('ResolverTestCase', () { | |
| 830 }); | |
| 831 } | |
| 832 } | |
| 833 class TypeProviderImplTest extends EngineTestCase { | |
| 834 void test_creation() { | |
| 835 InterfaceType objectType = classElement("Object", null, []).type; | |
| 836 InterfaceType boolType = classElement("bool", objectType, []).type; | |
| 837 InterfaceType numType = classElement("num", objectType, []).type; | |
| 838 InterfaceType doubleType = classElement("double", numType, []).type; | |
| 839 InterfaceType functionType = classElement("Function", objectType, []).type; | |
| 840 InterfaceType intType = classElement("int", numType, []).type; | |
| 841 InterfaceType listType = classElement("List", objectType, ["E"]).type; | |
| 842 InterfaceType mapType = classElement("Map", objectType, ["K", "V"]).type; | |
| 843 InterfaceType stackTraceType = classElement("StackTrace", objectType, []).ty
pe; | |
| 844 InterfaceType stringType = classElement("String", objectType, []).type; | |
| 845 InterfaceType typeType = classElement("Type", objectType, []).type; | |
| 846 CompilationUnitElementImpl unit = new CompilationUnitElementImpl("lib.dart")
; | |
| 847 unit.types = <ClassElement> [boolType.element, doubleType.element, functionT
ype.element, intType.element, listType.element, mapType.element, objectType.elem
ent, stackTraceType.element, stringType.element, typeType.element]; | |
| 848 LibraryElementImpl library = new LibraryElementImpl(new AnalysisContextImpl(
), ASTFactory.libraryIdentifier2(["lib"])); | |
| 849 library.definingCompilationUnit = unit; | |
| 850 TypeProviderImpl provider = new TypeProviderImpl(library); | |
| 851 JUnitTestCase.assertSame(boolType, provider.boolType); | |
| 852 JUnitTestCase.assertNotNull(provider.bottomType); | |
| 853 JUnitTestCase.assertSame(doubleType, provider.doubleType); | |
| 854 JUnitTestCase.assertNotNull(provider.dynamicType); | |
| 855 JUnitTestCase.assertSame(functionType, provider.functionType); | |
| 856 JUnitTestCase.assertSame(intType, provider.intType); | |
| 857 JUnitTestCase.assertSame(listType, provider.listType); | |
| 858 JUnitTestCase.assertSame(mapType, provider.mapType); | |
| 859 JUnitTestCase.assertSame(objectType, provider.objectType); | |
| 860 JUnitTestCase.assertSame(stackTraceType, provider.stackTraceType); | |
| 861 JUnitTestCase.assertSame(stringType, provider.stringType); | |
| 862 JUnitTestCase.assertSame(typeType, provider.typeType); | |
| 863 } | |
| 864 ClassElement classElement(String typeName, InterfaceType superclassType, List<
String> parameterNames) { | |
| 865 ClassElementImpl element = new ClassElementImpl(ASTFactory.identifier2(typeN
ame)); | |
| 866 element.supertype = superclassType; | |
| 867 InterfaceTypeImpl type = new InterfaceTypeImpl.con1(element); | |
| 868 element.type = type; | |
| 869 int count = parameterNames.length; | |
| 870 if (count > 0) { | |
| 871 List<TypeVariableElementImpl> typeVariables = new List<TypeVariableElement
Impl>(count); | |
| 872 List<TypeVariableTypeImpl> typeArguments = new List<TypeVariableTypeImpl>(
count); | |
| 873 for (int i = 0; i < count; i++) { | |
| 874 TypeVariableElementImpl variable = new TypeVariableElementImpl(ASTFactor
y.identifier2(parameterNames[i])); | |
| 875 typeVariables[i] = variable; | |
| 876 typeArguments[i] = new TypeVariableTypeImpl(variable); | |
| 877 variable.type = typeArguments[i]; | |
| 878 } | |
| 879 element.typeVariables = typeVariables; | |
| 880 type.typeArguments = typeArguments; | |
| 881 } | |
| 882 return element; | |
| 883 } | |
| 884 static dartSuite() { | |
| 885 _ut.group('TypeProviderImplTest', () { | |
| 886 _ut.test('test_creation', () { | |
| 887 final __test = new TypeProviderImplTest(); | |
| 888 runJUnitTest(__test, __test.test_creation); | |
| 889 }); | |
| 890 }); | |
| 891 } | |
| 892 } | |
| 893 class CompileTimeErrorCodeTest extends ResolverTestCase { | |
| 894 void fail_ambiguousExport() { | |
| 895 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y L;", "export 'lib1.dart';", "export 'lib2.dart';"])); | |
| 896 addSource("/lib1.dart", EngineTestCase.createSource(["class N {}"])); | |
| 897 addSource("/lib2.dart", EngineTestCase.createSource(["class N {}"])); | |
| 898 resolve(source, []); | |
| 899 assertErrors([CompileTimeErrorCode.AMBIGUOUS_EXPORT]); | |
| 900 verify([source]); | |
| 901 } | |
| 902 void fail_ambiguousImport_function() { | |
| 903 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y L;", "import 'lib1.dart';", "import 'lib2.dart';", "g() { return f(); }"])); | |
| 904 addSource("/lib1.dart", EngineTestCase.createSource(["f() {}"])); | |
| 905 addSource("/lib2.dart", EngineTestCase.createSource(["f() {}"])); | |
| 906 resolve(source, []); | |
| 907 assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]); | |
| 908 verify([source]); | |
| 909 } | |
| 910 void fail_ambiguousImport_typeAnnotation() { | |
| 911 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y L;", "import 'lib1.dart';", "import 'lib2.dart';", "class A extends N {}"])); | |
| 912 addSource("/lib1.dart", EngineTestCase.createSource(["class N {}"])); | |
| 913 addSource("/lib2.dart", EngineTestCase.createSource(["class N {}"])); | |
| 914 resolve(source, []); | |
| 915 assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]); | |
| 916 verify([source]); | |
| 917 } | |
| 918 void fail_caseExpressionTypeImplementsEquals() { | |
| 919 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
IntWrapper {", " final int value;", " const IntWrapper(this.value);", " bool
operator ==(IntWrapper x) {", " return value == x.value;", " }", "}", "", "f
(IntWrapper a) {", " switch(a) {", " case(const IntWrapper(1)) : return 1;",
" default: return 0;", " }", "}"])); | |
| 920 resolve(source, []); | |
| 921 assertErrors([CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]); | |
| 922 verify([source]); | |
| 923 } | |
| 924 void fail_compileTimeConstantRaisesException() { | |
| 925 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 926 resolve(source, []); | |
| 927 assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]); | |
| 928 verify([source]); | |
| 929 } | |
| 930 void fail_constEvalThrowsException() { | |
| 931 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
C {", " const C() { throw null; }", "}", "f() { return const C(); }"])); | |
| 932 resolve(source, []); | |
| 933 assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]); | |
| 934 verify([source]); | |
| 935 } | |
| 936 void fail_constWithNonConst() { | |
| 937 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
T {", " T(a, b, {c, d}) {};", "}", "f() { return const T(0, 1, c: 2, d: 3); }"]
)); | |
| 938 resolve(source, []); | |
| 939 assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]); | |
| 940 verify([source]); | |
| 941 } | |
| 942 void fail_constWithNonConstantArgument() { | |
| 943 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
T {", " T(a) {};", "}", "f(p) { return const T(p); }"])); | |
| 944 resolve(source, []); | |
| 945 assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]); | |
| 946 verify([source]); | |
| 947 } | |
| 948 void fail_constWithNonType() { | |
| 949 Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;
", "f() {", " return const A();", "}"])); | |
| 950 resolve(source, []); | |
| 951 assertErrors([CompileTimeErrorCode.CONST_WITH_NON_TYPE]); | |
| 952 verify([source]); | |
| 953 } | |
| 954 void fail_constWithTypeParameters() { | |
| 955 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 956 resolve(source, []); | |
| 957 assertErrors([CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS]); | |
| 958 verify([source]); | |
| 959 } | |
| 960 void fail_constWithUndefinedConstructor() { | |
| 961 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A(x) {}", "}", "f() {", " return const A(0);", "}"])); | |
| 962 resolve(source, []); | |
| 963 assertErrors([CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]); | |
| 964 verify([source]); | |
| 965 } | |
| 966 void fail_defaultValueInFunctionTypeAlias() { | |
| 967 Source source = addSource("/test.dart", EngineTestCase.createSource(["typede
f F([x = 0]);"])); | |
| 968 resolve(source, []); | |
| 969 assertErrors([CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]); | |
| 970 verify([source]); | |
| 971 } | |
| 972 void fail_duplicateDefinition() { | |
| 973 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " int m = 0;", " m(a) {}", "}"])); | |
| 974 resolve(source, []); | |
| 975 assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]); | |
| 976 verify([source]); | |
| 977 } | |
| 978 void fail_duplicateMemberName() { | |
| 979 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x = 0;", " int x() {}", "}"])); | |
| 980 resolve(source, []); | |
| 981 assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME]); | |
| 982 verify([source]); | |
| 983 } | |
| 984 void fail_duplicateMemberNameInstanceStatic() { | |
| 985 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " static int x;", "}"])); | |
| 986 resolve(source, []); | |
| 987 assertErrors([CompileTimeErrorCode.DUPLICATE_MEMBER_NAME_INSTANCE_STATIC]); | |
| 988 verify([source]); | |
| 989 } | |
| 990 void fail_duplicateNamedArgument() { | |
| 991 Source source = addSource("/test.dart", EngineTestCase.createSource(["f({a,
a}) {}"])); | |
| 992 resolve(source, []); | |
| 993 assertErrors([CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT]); | |
| 994 verify([source]); | |
| 995 } | |
| 996 void fail_exportOfNonLibrary() { | |
| 997 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y L;", "export 'lib1.dart';"])); | |
| 998 addSource("/lib1.dart", EngineTestCase.createSource(["part of lib;"])); | |
| 999 resolve(source, []); | |
| 1000 assertErrors([CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]); | |
| 1001 verify([source]); | |
| 1002 } | |
| 1003 void fail_extendsOrImplementsDisallowedClass_extends_bool() { | |
| 1004 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends bool {}"])); | |
| 1005 resolve(source, []); | |
| 1006 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1007 verify([source]); | |
| 1008 } | |
| 1009 void fail_extendsOrImplementsDisallowedClass_extends_double() { | |
| 1010 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends double {}"])); | |
| 1011 resolve(source, []); | |
| 1012 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1013 verify([source]); | |
| 1014 } | |
| 1015 void fail_extendsOrImplementsDisallowedClass_extends_int() { | |
| 1016 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends int {}"])); | |
| 1017 resolve(source, []); | |
| 1018 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1019 verify([source]); | |
| 1020 } | |
| 1021 void fail_extendsOrImplementsDisallowedClass_extends_null() { | |
| 1022 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends Null {}"])); | |
| 1023 resolve(source, []); | |
| 1024 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1025 verify([source]); | |
| 1026 } | |
| 1027 void fail_extendsOrImplementsDisallowedClass_extends_num() { | |
| 1028 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends num {}"])); | |
| 1029 resolve(source, []); | |
| 1030 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1031 verify([source]); | |
| 1032 } | |
| 1033 void fail_extendsOrImplementsDisallowedClass_extends_String() { | |
| 1034 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends String {}"])); | |
| 1035 resolve(source, []); | |
| 1036 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1037 verify([source]); | |
| 1038 } | |
| 1039 void fail_extendsOrImplementsDisallowedClass_implements_bool() { | |
| 1040 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements bool {}"])); | |
| 1041 resolve(source, []); | |
| 1042 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1043 verify([source]); | |
| 1044 } | |
| 1045 void fail_extendsOrImplementsDisallowedClass_implements_double() { | |
| 1046 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements double {}"])); | |
| 1047 resolve(source, []); | |
| 1048 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1049 verify([source]); | |
| 1050 } | |
| 1051 void fail_extendsOrImplementsDisallowedClass_implements_int() { | |
| 1052 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements int {}"])); | |
| 1053 resolve(source, []); | |
| 1054 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1055 verify([source]); | |
| 1056 } | |
| 1057 void fail_extendsOrImplementsDisallowedClass_implements_null() { | |
| 1058 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements Null {}"])); | |
| 1059 resolve(source, []); | |
| 1060 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1061 verify([source]); | |
| 1062 } | |
| 1063 void fail_extendsOrImplementsDisallowedClass_implements_num() { | |
| 1064 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements num {}"])); | |
| 1065 resolve(source, []); | |
| 1066 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1067 verify([source]); | |
| 1068 } | |
| 1069 void fail_extendsOrImplementsDisallowedClass_implements_String() { | |
| 1070 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements String {}"])); | |
| 1071 resolve(source, []); | |
| 1072 assertErrors([CompileTimeErrorCode.EXTENDS_OR_IMPLEMENTS_DISALLOWED_CLASS]); | |
| 1073 verify([source]); | |
| 1074 } | |
| 1075 void fail_fieldInitializedByMultipleInitializers() { | |
| 1076 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " A() : x = 0, x = 1 {}", "}"])); | |
| 1077 resolve(source, []); | |
| 1078 assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZER
S]); | |
| 1079 verify([source]); | |
| 1080 } | |
| 1081 void fail_fieldInitializedInInitializerAndDeclaration() { | |
| 1082 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " final int x = 0;", " A() : x = 1 {}", "}"])); | |
| 1083 resolve(source, []); | |
| 1084 assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECL
ARATION]); | |
| 1085 verify([source]); | |
| 1086 } | |
| 1087 void fail_fieldInitializeInParameterAndInitializer() { | |
| 1088 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " A(this.x) : x = 1 {}", "}"])); | |
| 1089 resolve(source, []); | |
| 1090 assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIA
LIZER]); | |
| 1091 verify([source]); | |
| 1092 } | |
| 1093 void fail_fieldInitializerOutsideConstructor() { | |
| 1094 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " m(this.x) {}", "}"])); | |
| 1095 resolve(source, []); | |
| 1096 assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]); | |
| 1097 verify([source]); | |
| 1098 } | |
| 1099 void fail_finalInitializedInDeclarationAndConstructor_assignment() { | |
| 1100 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " final x = 0;", " A() { x = 1; }", "}"])); | |
| 1101 resolve(source, []); | |
| 1102 assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONS
TRUCTOR]); | |
| 1103 verify([source]); | |
| 1104 } | |
| 1105 void fail_finalInitializedInDeclarationAndConstructor_initializingFormal() { | |
| 1106 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " final x = 0;", " A(this.x) {}", "}"])); | |
| 1107 resolve(source, []); | |
| 1108 assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONS
TRUCTOR]); | |
| 1109 verify([source]); | |
| 1110 } | |
| 1111 void fail_finalInitializedMultipleTimes() { | |
| 1112 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " final x;", " A(this.x) { x = 0; }", "}"])); | |
| 1113 resolve(source, []); | |
| 1114 assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES]); | |
| 1115 verify([source]); | |
| 1116 } | |
| 1117 void fail_finalNotInitialized_library() { | |
| 1118 Source source = addSource("/test.dart", EngineTestCase.createSource(["final
F;"])); | |
| 1119 resolve(source, []); | |
| 1120 assertErrors([CompileTimeErrorCode.FINAL_NOT_INITIALIZED]); | |
| 1121 verify([source]); | |
| 1122 } | |
| 1123 void fail_finalNotInitialized_local() { | |
| 1124 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " final int x;", "}"])); | |
| 1125 resolve(source, []); | |
| 1126 assertErrors([CompileTimeErrorCode.FINAL_NOT_INITIALIZED]); | |
| 1127 verify([source]); | |
| 1128 } | |
| 1129 void fail_finalNotInitialized_static() { | |
| 1130 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static final F;", "}"])); | |
| 1131 resolve(source, []); | |
| 1132 assertErrors([CompileTimeErrorCode.FINAL_NOT_INITIALIZED]); | |
| 1133 verify([source]); | |
| 1134 } | |
| 1135 void fail_getterAndMethodWithSameName() { | |
| 1136 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " get x -> 0;", " x(y) {}", "}"])); | |
| 1137 resolve(source, []); | |
| 1138 assertErrors([CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]); | |
| 1139 verify([source]); | |
| 1140 } | |
| 1141 void fail_implementsDynamic() { | |
| 1142 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements dynamic {}"])); | |
| 1143 resolve(source, []); | |
| 1144 assertErrors([CompileTimeErrorCode.IMPLEMENTS_DYNAMIC]); | |
| 1145 verify([source]); | |
| 1146 } | |
| 1147 void fail_implementsRepeated() { | |
| 1148 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B implements A, A {}"])); | |
| 1149 resolve(source, []); | |
| 1150 assertErrors([CompileTimeErrorCode.IMPLEMENTS_REPEATED]); | |
| 1151 verify([source]); | |
| 1152 } | |
| 1153 void fail_implementsSelf() { | |
| 1154 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements A {}"])); | |
| 1155 resolve(source, []); | |
| 1156 assertErrors([CompileTimeErrorCode.IMPLEMENTS_SELF]); | |
| 1157 verify([source]); | |
| 1158 } | |
| 1159 void fail_importDuplicatedLibraryName() { | |
| 1160 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y test;", "import 'lib1.dart';", "import 'lib2.dart';"])); | |
| 1161 addSource("/lib1.dart", EngineTestCase.createSource(["library lib;"])); | |
| 1162 addSource("/lib2.dart", EngineTestCase.createSource(["library lib;"])); | |
| 1163 resolve(source, []); | |
| 1164 assertErrors([CompileTimeErrorCode.IMPORT_DUPLICATED_LIBRARY_NAME]); | |
| 1165 verify([source]); | |
| 1166 } | |
| 1167 void fail_importOfNonLibrary() { | |
| 1168 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y lib;", "import 'part.dart';"])); | |
| 1169 addSource("/part.dart", EngineTestCase.createSource(["part of lib;"])); | |
| 1170 resolve(source, []); | |
| 1171 assertErrors([CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]); | |
| 1172 verify([source]); | |
| 1173 } | |
| 1174 void fail_inconsistentCaseExpressionTypes() { | |
| 1175 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var
p) {", " switch (p) {", " case 3:", " break;", " case 'a':", "
break;", " }", "}"])); | |
| 1176 resolve(source, []); | |
| 1177 assertErrors([CompileTimeErrorCode.INCONSITENT_CASE_EXPRESSION_TYPES]); | |
| 1178 verify([source]); | |
| 1179 } | |
| 1180 void fail_initializerForNonExistantField() { | |
| 1181 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A(this.x) {}", "}"])); | |
| 1182 resolve(source, []); | |
| 1183 assertErrors([CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTANT_FIELD]); | |
| 1184 verify([source]); | |
| 1185 } | |
| 1186 void fail_invalidConstructorName() { | |
| 1187 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1188 resolve(source, []); | |
| 1189 assertErrors([CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]); | |
| 1190 verify([source]); | |
| 1191 } | |
| 1192 void fail_invalidFactoryNameNotAClass() { | |
| 1193 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1194 resolve(source, []); | |
| 1195 assertErrors([CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]); | |
| 1196 verify([source]); | |
| 1197 } | |
| 1198 void fail_invalidOverrideDefaultValue() { | |
| 1199 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m([a = 0]) {}", "}", "class B extends A {", " m([a = 1]) {}", "}"])); | |
| 1200 resolve(source, []); | |
| 1201 assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_DEFAULT_VALUE]); | |
| 1202 verify([source]); | |
| 1203 } | |
| 1204 void fail_invalidOverrideNamed() { | |
| 1205 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m({a, b}) {}", "}", "class B extends A {", " m({a}) {}", "}"])); | |
| 1206 resolve(source, []); | |
| 1207 assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_NAMED]); | |
| 1208 verify([source]); | |
| 1209 } | |
| 1210 void fail_invalidOverridePositional() { | |
| 1211 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m([a, b]) {}", "}", "class B extends A {", " m([a]) {}", "}"])); | |
| 1212 resolve(source, []); | |
| 1213 assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_POSITIONAL]); | |
| 1214 verify([source]); | |
| 1215 } | |
| 1216 void fail_invalidOverrideRequired() { | |
| 1217 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m(a) {}", "}", "class B extends A {", " m(a, b) {}", "}"])); | |
| 1218 resolve(source, []); | |
| 1219 assertErrors([CompileTimeErrorCode.INVALID_OVERRIDE_REQUIRED]); | |
| 1220 verify([source]); | |
| 1221 } | |
| 1222 void fail_invalidReferenceToThis_staticMethod() { | |
| 1223 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static m() { return this; }", "}"])); | |
| 1224 resolve(source, []); | |
| 1225 assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]); | |
| 1226 verify([source]); | |
| 1227 } | |
| 1228 void fail_invalidReferenceToThis_topLevelFunction() { | |
| 1229 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {
return this; }"])); | |
| 1230 resolve(source, []); | |
| 1231 assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]); | |
| 1232 verify([source]); | |
| 1233 } | |
| 1234 void fail_invalidReferenceToThis_variableInitializer() { | |
| 1235 Source source = addSource("/test.dart", EngineTestCase.createSource(["int x
= this;"])); | |
| 1236 resolve(source, []); | |
| 1237 assertErrors([CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]); | |
| 1238 verify([source]); | |
| 1239 } | |
| 1240 void fail_invalidTypeArgumentForKey() { | |
| 1241 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m() {", " return const <int, int>{}", " }", "}"])); | |
| 1242 resolve(source, []); | |
| 1243 assertErrors([CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_FOR_KEY]); | |
| 1244 verify([source]); | |
| 1245 } | |
| 1246 void fail_invalidTypeArgumentInConstList() { | |
| 1247 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A<E> {", " m() {", " return const <E>[]", " }", "}"])); | |
| 1248 resolve(source, []); | |
| 1249 assertErrors([CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST]); | |
| 1250 verify([source]); | |
| 1251 } | |
| 1252 void fail_invalidTypeArgumentInConstMap() { | |
| 1253 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A<E> {", " m() {", " return const <String, E>{}", " }", "}"])); | |
| 1254 resolve(source, []); | |
| 1255 assertErrors([CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP]); | |
| 1256 verify([source]); | |
| 1257 } | |
| 1258 void fail_invalidVariableInInitializer_nonField() { | |
| 1259 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A(this.x) {}", "}"])); | |
| 1260 resolve(source, []); | |
| 1261 assertErrors([CompileTimeErrorCode.INVALID_VARIABLE_IN_INITIALIZER]); | |
| 1262 verify([source]); | |
| 1263 } | |
| 1264 void fail_invalidVariableInInitializer_static() { | |
| 1265 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static x = 0;", " A(this.x) {}", "}"])); | |
| 1266 resolve(source, []); | |
| 1267 assertErrors([CompileTimeErrorCode.INVALID_VARIABLE_IN_INITIALIZER]); | |
| 1268 verify([source]); | |
| 1269 } | |
| 1270 void fail_memberWithClassName() { | |
| 1271 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int A = 0;", "}"])); | |
| 1272 resolve(source, []); | |
| 1273 assertErrors([CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]); | |
| 1274 verify([source]); | |
| 1275 } | |
| 1276 void fail_mixinDeclaresConstructor() { | |
| 1277 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A() {}", "}", "class B extends Object mixin A {}"])); | |
| 1278 resolve(source, []); | |
| 1279 assertErrors([CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]); | |
| 1280 verify([source]); | |
| 1281 } | |
| 1282 void fail_mixinInheritsFromNotObject() { | |
| 1283 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {}", "class C extends Object mixin B {}"])); | |
| 1284 resolve(source, []); | |
| 1285 assertErrors([CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]); | |
| 1286 verify([source]); | |
| 1287 } | |
| 1288 void fail_mixinOfNonClass() { | |
| 1289 Source source = addSource("/test.dart", EngineTestCase.createSource(["var A;
", "class B extends Object mixin A {}"])); | |
| 1290 resolve(source, []); | |
| 1291 assertErrors([CompileTimeErrorCode.MIXIN_OF_NON_CLASS]); | |
| 1292 verify([source]); | |
| 1293 } | |
| 1294 void fail_mixinOfNonMixin() { | |
| 1295 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1296 resolve(source, []); | |
| 1297 assertErrors([CompileTimeErrorCode.MIXIN_OF_NON_MIXIN]); | |
| 1298 verify([source]); | |
| 1299 } | |
| 1300 void fail_mixinReferencesSuper() { | |
| 1301 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " toString() -> super.toString();", "}", "class B extends Object mixin A
{}"])); | |
| 1302 resolve(source, []); | |
| 1303 assertErrors([CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]); | |
| 1304 verify([source]); | |
| 1305 } | |
| 1306 void fail_mixinWithNonClassSuperclass() { | |
| 1307 Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;
", "class B extends Object mixin A {}"])); | |
| 1308 resolve(source, []); | |
| 1309 assertErrors([CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]); | |
| 1310 verify([source]); | |
| 1311 } | |
| 1312 void fail_multipleSuperInitializers() { | |
| 1313 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {", " B() : super(), super() {}", "}"])); | |
| 1314 resolve(source, []); | |
| 1315 assertErrors([CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]); | |
| 1316 verify([source]); | |
| 1317 } | |
| 1318 void fail_nonConstantDefaultValue_named() { | |
| 1319 Source source = addSource("/test.dart", EngineTestCase.createSource(["f({x :
2 + 3}) {}"])); | |
| 1320 resolve(source, []); | |
| 1321 assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]); | |
| 1322 verify([source]); | |
| 1323 } | |
| 1324 void fail_nonConstantDefaultValue_positional() { | |
| 1325 Source source = addSource("/test.dart", EngineTestCase.createSource(["f([x =
2 + 3]) {}"])); | |
| 1326 resolve(source, []); | |
| 1327 assertErrors([CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]); | |
| 1328 verify([source]); | |
| 1329 } | |
| 1330 void fail_nonConstCaseExpression() { | |
| 1331 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int
p) {", " switch (p) {", " case 3 + 4:", " break;", " }", "}"])); | |
| 1332 resolve(source, []); | |
| 1333 assertErrors([CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]); | |
| 1334 verify([source]); | |
| 1335 } | |
| 1336 void fail_nonConstMapAsExpressionStatement() { | |
| 1337 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " {'a' : 0, 'b' : 1};", "}"])); | |
| 1338 resolve(source, []); | |
| 1339 assertErrors([CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]); | |
| 1340 verify([source]); | |
| 1341 } | |
| 1342 void fail_nonConstMapKey() { | |
| 1343 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {
", " return const {a : 0};", "}"])); | |
| 1344 resolve(source, []); | |
| 1345 assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_KEY]); | |
| 1346 verify([source]); | |
| 1347 } | |
| 1348 void fail_nonConstValueInInitializer() { | |
| 1349 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static C;", " int a;", " A() : a = C {}", "}"])); | |
| 1350 resolve(source, []); | |
| 1351 assertErrors([CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]); | |
| 1352 verify([source]); | |
| 1353 } | |
| 1354 void fail_objectCannotExtendAnotherClass() { | |
| 1355 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1356 resolve(source, []); | |
| 1357 assertErrors([CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]); | |
| 1358 verify([source]); | |
| 1359 } | |
| 1360 void fail_optionalParameterInOperator() { | |
| 1361 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " operator +([p]) {}", "}"])); | |
| 1362 resolve(source, []); | |
| 1363 assertErrors([CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]); | |
| 1364 verify([source]); | |
| 1365 } | |
| 1366 void fail_overrideMissingNamedParameters() { | |
| 1367 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m(a, {b}) {}", "}", "class B extends A {", " m(a) {}", "}"])); | |
| 1368 resolve(source, []); | |
| 1369 assertErrors([CompileTimeErrorCode.OVERRIDE_MISSING_NAMED_PARAMETERS]); | |
| 1370 verify([source]); | |
| 1371 } | |
| 1372 void fail_overrideMissingRequiredParameters() { | |
| 1373 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m(a) {}", "}", "class B extends A {", " m(a, b) {}", "}"])); | |
| 1374 resolve(source, []); | |
| 1375 assertErrors([CompileTimeErrorCode.OVERRIDE_MISSING_REQUIRED_PARAMETERS]); | |
| 1376 verify([source]); | |
| 1377 } | |
| 1378 void fail_partOfNonPart() { | |
| 1379 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y l1;", "part 'l2.dart';"])); | |
| 1380 addSource("/l2.dart", EngineTestCase.createSource(["library l2;"])); | |
| 1381 resolve(source, []); | |
| 1382 assertErrors([CompileTimeErrorCode.PART_OF_NON_PART]); | |
| 1383 verify([source]); | |
| 1384 } | |
| 1385 void fail_prefixCollidesWithTopLevelMembers() { | |
| 1386 Source source = addSource("/test.dart", EngineTestCase.createSource(["import
'dart:uri' as uri;", "var uri = null;"])); | |
| 1387 resolve(source, []); | |
| 1388 assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]); | |
| 1389 verify([source]); | |
| 1390 } | |
| 1391 void fail_privateOptionalParameter() { | |
| 1392 Source source = addSource("/test.dart", EngineTestCase.createSource(["f({_p
: 0}) {}"])); | |
| 1393 resolve(source, []); | |
| 1394 assertErrors([CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]); | |
| 1395 verify([source]); | |
| 1396 } | |
| 1397 void fail_recursiveCompileTimeConstant() { | |
| 1398 Source source = addSource("/test.dart", EngineTestCase.createSource(["const
x = y + 1;", "const y = x + 1;"])); | |
| 1399 resolve(source, []); | |
| 1400 assertErrors([CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]); | |
| 1401 verify([source]); | |
| 1402 } | |
| 1403 void fail_recursiveFactoryRedirect() { | |
| 1404 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1405 resolve(source, []); | |
| 1406 assertErrors([CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT]); | |
| 1407 verify([source]); | |
| 1408 } | |
| 1409 void fail_recursiveFunctionTypeAlias_direct() { | |
| 1410 Source source = addSource("/test.dart", EngineTestCase.createSource(["typede
f F(F f);"])); | |
| 1411 resolve(source, []); | |
| 1412 assertErrors([CompileTimeErrorCode.RECURSIVE_FUNCTION_TYPE_ALIAS]); | |
| 1413 verify([source]); | |
| 1414 } | |
| 1415 void fail_recursiveFunctionTypeAlias_indirect() { | |
| 1416 Source source = addSource("/test.dart", EngineTestCase.createSource(["typede
f F(G g);", "typedef G(F f);"])); | |
| 1417 resolve(source, []); | |
| 1418 assertErrors([CompileTimeErrorCode.RECURSIVE_FUNCTION_TYPE_ALIAS]); | |
| 1419 verify([source]); | |
| 1420 } | |
| 1421 void fail_recursiveInterfaceInheritance_direct() { | |
| 1422 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements A {}"])); | |
| 1423 resolve(source, []); | |
| 1424 assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]); | |
| 1425 verify([source]); | |
| 1426 } | |
| 1427 void fail_recursiveInterfaceInheritance_indirect() { | |
| 1428 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A implements B {}", "class B implements A {}"])); | |
| 1429 resolve(source, []); | |
| 1430 assertErrors([CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE]); | |
| 1431 verify([source]); | |
| 1432 } | |
| 1433 void fail_redirectToNonConstConstructor() { | |
| 1434 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1435 resolve(source, []); | |
| 1436 assertErrors([CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR]); | |
| 1437 verify([source]); | |
| 1438 } | |
| 1439 void fail_referenceToDeclaredVariableInInitializer_getter() { | |
| 1440 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " int x = x + 1;", "}"])); | |
| 1441 resolve(source, []); | |
| 1442 assertErrors([CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIAL
IZER]); | |
| 1443 verify([source]); | |
| 1444 } | |
| 1445 void fail_referenceToDeclaredVariableInInitializer_setter() { | |
| 1446 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " int x = x++;", "}"])); | |
| 1447 resolve(source, []); | |
| 1448 assertErrors([CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIAL
IZER]); | |
| 1449 verify([source]); | |
| 1450 } | |
| 1451 void fail_reservedWordAsIdentifier() { | |
| 1452 Source source = addSource("/test.dart", EngineTestCase.createSource(["int cl
ass = 2;"])); | |
| 1453 resolve(source, []); | |
| 1454 assertErrors([CompileTimeErrorCode.RESERVED_WORD_AS_IDENTIFIER]); | |
| 1455 verify([source]); | |
| 1456 } | |
| 1457 void fail_returnInGenerativeConstructor() { | |
| 1458 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A() { return 0; }", "}"])); | |
| 1459 resolve(source, []); | |
| 1460 assertErrors([CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]); | |
| 1461 verify([source]); | |
| 1462 } | |
| 1463 void fail_staticTopLevelFunction_topLevel() { | |
| 1464 Source source = addSource("/test.dart", EngineTestCase.createSource(["static
f() {}"])); | |
| 1465 resolve(source, []); | |
| 1466 assertErrors([CompileTimeErrorCode.STATIC_TOP_LEVEL_FUNCTION]); | |
| 1467 verify([source]); | |
| 1468 } | |
| 1469 void fail_staticTopLevelVariable() { | |
| 1470 Source source = addSource("/test.dart", EngineTestCase.createSource(["static
int x;"])); | |
| 1471 resolve(source, []); | |
| 1472 assertErrors([CompileTimeErrorCode.STATIC_TOP_LEVEL_VARIABLE]); | |
| 1473 verify([source]); | |
| 1474 } | |
| 1475 void fail_superInInvalidContext_factoryConstructor() { | |
| 1476 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1477 resolve(source, []); | |
| 1478 assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]); | |
| 1479 verify([source]); | |
| 1480 } | |
| 1481 void fail_superInInvalidContext_instanceVariableInitializer() { | |
| 1482 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " var a;", "}", "class B extends A {", " var b = super.a;", "}"])); | |
| 1483 resolve(source, []); | |
| 1484 assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]); | |
| 1485 verify([source]); | |
| 1486 } | |
| 1487 void fail_superInInvalidContext_staticMethod() { | |
| 1488 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static m() {}", "}", "class B extends A {", " static n() { return supe
r.m(); }", "}"])); | |
| 1489 resolve(source, []); | |
| 1490 assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]); | |
| 1491 verify([source]); | |
| 1492 } | |
| 1493 void fail_superInInvalidContext_staticVariableInitializer() { | |
| 1494 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static a = 0;", "}", "class B extends A {", " static b = super.a;", "}
"])); | |
| 1495 resolve(source, []); | |
| 1496 assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]); | |
| 1497 verify([source]); | |
| 1498 } | |
| 1499 void fail_superInInvalidContext_topLevelFunction() { | |
| 1500 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " super.f();", "}"])); | |
| 1501 resolve(source, []); | |
| 1502 assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]); | |
| 1503 verify([source]); | |
| 1504 } | |
| 1505 void fail_superInInvalidContext_variableInitializer() { | |
| 1506 Source source = addSource("/test.dart", EngineTestCase.createSource(["var v
= super.v;"])); | |
| 1507 resolve(source, []); | |
| 1508 assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]); | |
| 1509 verify([source]); | |
| 1510 } | |
| 1511 void fail_superInitializerInObject() { | |
| 1512 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1513 resolve(source, []); | |
| 1514 assertErrors([CompileTimeErrorCode.SUPER_INITIALIZER_IN_OBJECT]); | |
| 1515 verify([source]); | |
| 1516 } | |
| 1517 void fail_throwWithoutValueOutsideOn() { | |
| 1518 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " throw;", "}"])); | |
| 1519 resolve(source, []); | |
| 1520 assertErrors([CompileTimeErrorCode.THROW_WITHOUT_VALUE_OUTSIDE_ON]); | |
| 1521 verify([source]); | |
| 1522 } | |
| 1523 void fail_typeArgumentsForNonGenericClass_creation_const() { | |
| 1524 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "f(p) {", " return const A<int>();", "}"])); | |
| 1525 resolve(source, []); | |
| 1526 assertErrors([CompileTimeErrorCode.TYPE_ARGUMENTS_FOR_NON_GENERIC_CLASS]); | |
| 1527 verify([source]); | |
| 1528 } | |
| 1529 void fail_typeArgumentsForNonGenericClass_creation_new() { | |
| 1530 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "f(p) {", " return new A<int>();", "}"])); | |
| 1531 resolve(source, []); | |
| 1532 assertErrors([CompileTimeErrorCode.TYPE_ARGUMENTS_FOR_NON_GENERIC_CLASS]); | |
| 1533 verify([source]); | |
| 1534 } | |
| 1535 void fail_typeArgumentsForNonGenericClass_typeCast() { | |
| 1536 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "f(p) {", " return p as A<int>;", "}"])); | |
| 1537 resolve(source, []); | |
| 1538 assertErrors([CompileTimeErrorCode.TYPE_ARGUMENTS_FOR_NON_GENERIC_CLASS]); | |
| 1539 verify([source]); | |
| 1540 } | |
| 1541 void fail_undefinedConstructorInInitializer() { | |
| 1542 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 1543 resolve(source, []); | |
| 1544 assertErrors([CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER]); | |
| 1545 verify([source]); | |
| 1546 } | |
| 1547 void fail_uninitializedFinalField() { | |
| 1548 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " final int i;", "}"])); | |
| 1549 resolve(source, []); | |
| 1550 assertErrors([CompileTimeErrorCode.UNINITIALIZED_FINAL_FIELD]); | |
| 1551 verify([source]); | |
| 1552 } | |
| 1553 void fail_wrongNumberOfParametersForOperator() { | |
| 1554 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " operator []=(i) {}", "}"])); | |
| 1555 resolve(source, []); | |
| 1556 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR])
; | |
| 1557 verify([source]); | |
| 1558 } | |
| 1559 void fail_wrongNumberOfParametersForSetter_tooFew() { | |
| 1560 Source source = addSource("/test.dart", EngineTestCase.createSource(["set x(
) {}"])); | |
| 1561 resolve(source, []); | |
| 1562 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]); | |
| 1563 verify([source]); | |
| 1564 } | |
| 1565 void fail_wrongNumberOfParametersForSetter_tooMany() { | |
| 1566 Source source = addSource("/test.dart", EngineTestCase.createSource(["set x(
a, b) {}"])); | |
| 1567 resolve(source, []); | |
| 1568 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]); | |
| 1569 verify([source]); | |
| 1570 } | |
| 1571 void fail_wrongNumberOfTypeArguments_creation_const_tooFew() { | |
| 1572 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class C<K, V> {}", "f(p) {", " return const C<A>();", "}"])); | |
| 1573 resolve(source, []); | |
| 1574 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 1575 verify([source]); | |
| 1576 } | |
| 1577 void fail_wrongNumberOfTypeArguments_creation_const_tooMany() { | |
| 1578 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class C<E> {}", "f(p) {", " return const C<A, A>();", "}"])); | |
| 1579 resolve(source, []); | |
| 1580 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 1581 verify([source]); | |
| 1582 } | |
| 1583 void fail_wrongNumberOfTypeArguments_creation_new_tooFew() { | |
| 1584 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class C<K, V> {}", "f(p) {", " return new C<A>();", "}"])); | |
| 1585 resolve(source, []); | |
| 1586 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 1587 verify([source]); | |
| 1588 } | |
| 1589 void fail_wrongNumberOfTypeArguments_creation_new_tooMany() { | |
| 1590 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class C<E> {}", "f(p) {", " return new C<A, A>();", "}"])); | |
| 1591 resolve(source, []); | |
| 1592 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 1593 verify([source]); | |
| 1594 } | |
| 1595 void fail_wrongNumberOfTypeArguments_typeTest_tooFew() { | |
| 1596 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class C<K, V> {}", "f(p) {", " return p is C<A>;", "}"])); | |
| 1597 resolve(source, []); | |
| 1598 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 1599 verify([source]); | |
| 1600 } | |
| 1601 void fail_wrongNumberOfTypeArguments_typeTest_tooMany() { | |
| 1602 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class C<E> {}", "f(p) {", " return p is C<A, A>;", "}"])); | |
| 1603 resolve(source, []); | |
| 1604 assertErrors([CompileTimeErrorCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]); | |
| 1605 verify([source]); | |
| 1606 } | |
| 1607 void test_argumentDefinitionTestNonParameter() { | |
| 1608 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " var v = 0;", " return ?v;", "}"])); | |
| 1609 resolve(source, []); | |
| 1610 assertErrors([CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER]); | |
| 1611 verify([source]); | |
| 1612 } | |
| 1613 void test_builtInIdentifierAsType() { | |
| 1614 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " typedef x;", "}"])); | |
| 1615 resolve(source, []); | |
| 1616 assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]); | |
| 1617 verify([source]); | |
| 1618 } | |
| 1619 void test_builtInIdentifierAsTypedefName_classTypeAlias() { | |
| 1620 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B {}", "typedef as = A with B;"])); | |
| 1621 resolve(source, []); | |
| 1622 assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]); | |
| 1623 verify([source]); | |
| 1624 } | |
| 1625 void test_builtInIdentifierAsTypedefName_functionTypeAlias() { | |
| 1626 Source source = addSource("/test.dart", EngineTestCase.createSource(["typede
f bool as();"])); | |
| 1627 resolve(source, []); | |
| 1628 assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]); | |
| 1629 verify([source]); | |
| 1630 } | |
| 1631 void test_builtInIdentifierAsTypeName() { | |
| 1632 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
as {}"])); | |
| 1633 resolve(source, []); | |
| 1634 assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]); | |
| 1635 verify([source]); | |
| 1636 } | |
| 1637 void test_builtInIdentifierAsTypeVariableName() { | |
| 1638 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A<as> {}"])); | |
| 1639 resolve(source, []); | |
| 1640 assertErrors([CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME
]); | |
| 1641 verify([source]); | |
| 1642 } | |
| 1643 void test_compileTimeConstantRaisesExceptionDivideByZero() { | |
| 1644 Source source = addSource("/test.dart", EngineTestCase.createSource(["const
int INF = 0 / 0;"])); | |
| 1645 resolve(source, []); | |
| 1646 assertErrors([CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION_DI
VIDE_BY_ZERO]); | |
| 1647 verify([source]); | |
| 1648 } | |
| 1649 void test_conflictingConstructorNameAndMember_field() { | |
| 1650 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " A.x() {}", "}"])); | |
| 1651 resolve(source, []); | |
| 1652 assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD]); | |
| 1653 verify([source]); | |
| 1654 } | |
| 1655 void test_conflictingConstructorNameAndMember_method() { | |
| 1656 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " const A.x() {}", " void x() {}", "}"])); | |
| 1657 resolve(source, []); | |
| 1658 assertErrors([CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD])
; | |
| 1659 verify([source]); | |
| 1660 } | |
| 1661 void test_constConstructorWithNonFinalField() { | |
| 1662 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " const A() {}", "}"])); | |
| 1663 resolve(source, []); | |
| 1664 assertErrors([CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]); | |
| 1665 verify([source]); | |
| 1666 } | |
| 1667 void test_constFormalParameter_fieldFormalParameter() { | |
| 1668 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " var x;", " A(const this.x) {}", "}"])); | |
| 1669 resolve(source, []); | |
| 1670 assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]); | |
| 1671 verify([source]); | |
| 1672 } | |
| 1673 void test_constFormalParameter_simpleFormalParameter() { | |
| 1674 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(cons
t x) {}"])); | |
| 1675 resolve(source, []); | |
| 1676 assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]); | |
| 1677 verify([source]); | |
| 1678 } | |
| 1679 void test_constInitializedWithNonConstValue() { | |
| 1680 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(p) {
", " const C = p;", "}"])); | |
| 1681 resolve(source, []); | |
| 1682 assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE
]); | |
| 1683 verify([source]); | |
| 1684 } | |
| 1685 void test_constWithInvalidTypeParameters() { | |
| 1686 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " const A() {}", "}", "f() { return const A<A>(); }"])); | |
| 1687 resolve(source, []); | |
| 1688 assertErrors([CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]); | |
| 1689 verify([source]); | |
| 1690 } | |
| 1691 void test_duplicateMemberError() { | |
| 1692 Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["
library lib;", "", "part 'a.dart';", "part 'b.dart';"])); | |
| 1693 Source sourceA = addSource("/a.dart", EngineTestCase.createSource(["part of
lib;", "", "class A {}"])); | |
| 1694 Source sourceB = addSource("/b.dart", EngineTestCase.createSource(["part of
lib;", "", "class A {}"])); | |
| 1695 resolve(librarySource, [sourceA, sourceB]); | |
| 1696 assertErrors([CompileTimeErrorCode.DUPLICATE_DEFINITION]); | |
| 1697 verify([librarySource, sourceA, sourceB]); | |
| 1698 } | |
| 1699 void test_extendsNonClass() { | |
| 1700 Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;
", "class B extends A {}"])); | |
| 1701 resolve(source, []); | |
| 1702 assertErrors([CompileTimeErrorCode.EXTENDS_NON_CLASS]); | |
| 1703 verify([source]); | |
| 1704 } | |
| 1705 void test_implementsNonClass() { | |
| 1706 Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;
", "class B implements A {}"])); | |
| 1707 resolve(source, []); | |
| 1708 assertErrors([CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]); | |
| 1709 verify([source]); | |
| 1710 } | |
| 1711 void test_labelInOuterScope() { | |
| 1712 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
int {}", "", "class A {", " void m(int i) {", " l: while (i > 0) {", "
void f() {", " break l;", " };", " }", " }", "}"])); | |
| 1713 resolve(source, []); | |
| 1714 assertErrors([CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, ResolverErrorCode.C
ANNOT_BE_RESOLVED]); | |
| 1715 } | |
| 1716 void test_labelUndefined_break() { | |
| 1717 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " x: while (true) {", " break y;", " }", "}"])); | |
| 1718 resolve(source, []); | |
| 1719 assertErrors([CompileTimeErrorCode.LABEL_UNDEFINED]); | |
| 1720 } | |
| 1721 void test_labelUndefined_continue() { | |
| 1722 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " x: while (true) {", " continue y;", " }", "}"])); | |
| 1723 resolve(source, []); | |
| 1724 assertErrors([CompileTimeErrorCode.LABEL_UNDEFINED]); | |
| 1725 } | |
| 1726 void test_newWithInvalidTypeParameters() { | |
| 1727 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "f() { return new A<A>(); }"])); | |
| 1728 resolve(source, []); | |
| 1729 assertErrors([CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]); | |
| 1730 verify([source]); | |
| 1731 } | |
| 1732 void test_nonConstListElement() { | |
| 1733 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {
", " return const [a];", "}"])); | |
| 1734 resolve(source, []); | |
| 1735 assertErrors([CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]); | |
| 1736 verify([source]); | |
| 1737 } | |
| 1738 void test_nonConstMapValue() { | |
| 1739 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {
", " return const {'a' : a};", "}"])); | |
| 1740 resolve(source, []); | |
| 1741 assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]); | |
| 1742 verify([source]); | |
| 1743 } | |
| 1744 void test_uriWithInterpolation_constant() { | |
| 1745 Source source = addSource("/test.dart", EngineTestCase.createSource(["import
'stuff_\$platform.dart';"])); | |
| 1746 resolve(source, []); | |
| 1747 assertErrors([CompileTimeErrorCode.URI_WITH_INTERPOLATION]); | |
| 1748 } | |
| 1749 void test_uriWithInterpolation_nonConstant() { | |
| 1750 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y lib;", "part '\${'a'}.dart';"])); | |
| 1751 resolve(source, []); | |
| 1752 assertErrors([CompileTimeErrorCode.URI_WITH_INTERPOLATION]); | |
| 1753 } | |
| 1754 static dartSuite() { | |
| 1755 _ut.group('CompileTimeErrorCodeTest', () { | |
| 1756 _ut.test('test_argumentDefinitionTestNonParameter', () { | |
| 1757 final __test = new CompileTimeErrorCodeTest(); | |
| 1758 runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter); | |
| 1759 }); | |
| 1760 _ut.test('test_builtInIdentifierAsType', () { | |
| 1761 final __test = new CompileTimeErrorCodeTest(); | |
| 1762 runJUnitTest(__test, __test.test_builtInIdentifierAsType); | |
| 1763 }); | |
| 1764 _ut.test('test_builtInIdentifierAsTypeName', () { | |
| 1765 final __test = new CompileTimeErrorCodeTest(); | |
| 1766 runJUnitTest(__test, __test.test_builtInIdentifierAsTypeName); | |
| 1767 }); | |
| 1768 _ut.test('test_builtInIdentifierAsTypeVariableName', () { | |
| 1769 final __test = new CompileTimeErrorCodeTest(); | |
| 1770 runJUnitTest(__test, __test.test_builtInIdentifierAsTypeVariableName); | |
| 1771 }); | |
| 1772 _ut.test('test_builtInIdentifierAsTypedefName_classTypeAlias', () { | |
| 1773 final __test = new CompileTimeErrorCodeTest(); | |
| 1774 runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_classTyp
eAlias); | |
| 1775 }); | |
| 1776 _ut.test('test_builtInIdentifierAsTypedefName_functionTypeAlias', () { | |
| 1777 final __test = new CompileTimeErrorCodeTest(); | |
| 1778 runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_function
TypeAlias); | |
| 1779 }); | |
| 1780 _ut.test('test_compileTimeConstantRaisesExceptionDivideByZero', () { | |
| 1781 final __test = new CompileTimeErrorCodeTest(); | |
| 1782 runJUnitTest(__test, __test.test_compileTimeConstantRaisesExceptionDivid
eByZero); | |
| 1783 }); | |
| 1784 _ut.test('test_conflictingConstructorNameAndMember_field', () { | |
| 1785 final __test = new CompileTimeErrorCodeTest(); | |
| 1786 runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_fie
ld); | |
| 1787 }); | |
| 1788 _ut.test('test_conflictingConstructorNameAndMember_method', () { | |
| 1789 final __test = new CompileTimeErrorCodeTest(); | |
| 1790 runJUnitTest(__test, __test.test_conflictingConstructorNameAndMember_met
hod); | |
| 1791 }); | |
| 1792 _ut.test('test_constConstructorWithNonFinalField', () { | |
| 1793 final __test = new CompileTimeErrorCodeTest(); | |
| 1794 runJUnitTest(__test, __test.test_constConstructorWithNonFinalField); | |
| 1795 }); | |
| 1796 _ut.test('test_constFormalParameter_fieldFormalParameter', () { | |
| 1797 final __test = new CompileTimeErrorCodeTest(); | |
| 1798 runJUnitTest(__test, __test.test_constFormalParameter_fieldFormalParamet
er); | |
| 1799 }); | |
| 1800 _ut.test('test_constFormalParameter_simpleFormalParameter', () { | |
| 1801 final __test = new CompileTimeErrorCodeTest(); | |
| 1802 runJUnitTest(__test, __test.test_constFormalParameter_simpleFormalParame
ter); | |
| 1803 }); | |
| 1804 _ut.test('test_constInitializedWithNonConstValue', () { | |
| 1805 final __test = new CompileTimeErrorCodeTest(); | |
| 1806 runJUnitTest(__test, __test.test_constInitializedWithNonConstValue); | |
| 1807 }); | |
| 1808 _ut.test('test_constWithInvalidTypeParameters', () { | |
| 1809 final __test = new CompileTimeErrorCodeTest(); | |
| 1810 runJUnitTest(__test, __test.test_constWithInvalidTypeParameters); | |
| 1811 }); | |
| 1812 _ut.test('test_duplicateMemberError', () { | |
| 1813 final __test = new CompileTimeErrorCodeTest(); | |
| 1814 runJUnitTest(__test, __test.test_duplicateMemberError); | |
| 1815 }); | |
| 1816 _ut.test('test_extendsNonClass', () { | |
| 1817 final __test = new CompileTimeErrorCodeTest(); | |
| 1818 runJUnitTest(__test, __test.test_extendsNonClass); | |
| 1819 }); | |
| 1820 _ut.test('test_implementsNonClass', () { | |
| 1821 final __test = new CompileTimeErrorCodeTest(); | |
| 1822 runJUnitTest(__test, __test.test_implementsNonClass); | |
| 1823 }); | |
| 1824 _ut.test('test_labelInOuterScope', () { | |
| 1825 final __test = new CompileTimeErrorCodeTest(); | |
| 1826 runJUnitTest(__test, __test.test_labelInOuterScope); | |
| 1827 }); | |
| 1828 _ut.test('test_labelUndefined_break', () { | |
| 1829 final __test = new CompileTimeErrorCodeTest(); | |
| 1830 runJUnitTest(__test, __test.test_labelUndefined_break); | |
| 1831 }); | |
| 1832 _ut.test('test_labelUndefined_continue', () { | |
| 1833 final __test = new CompileTimeErrorCodeTest(); | |
| 1834 runJUnitTest(__test, __test.test_labelUndefined_continue); | |
| 1835 }); | |
| 1836 _ut.test('test_newWithInvalidTypeParameters', () { | |
| 1837 final __test = new CompileTimeErrorCodeTest(); | |
| 1838 runJUnitTest(__test, __test.test_newWithInvalidTypeParameters); | |
| 1839 }); | |
| 1840 _ut.test('test_nonConstListElement', () { | |
| 1841 final __test = new CompileTimeErrorCodeTest(); | |
| 1842 runJUnitTest(__test, __test.test_nonConstListElement); | |
| 1843 }); | |
| 1844 _ut.test('test_nonConstMapValue', () { | |
| 1845 final __test = new CompileTimeErrorCodeTest(); | |
| 1846 runJUnitTest(__test, __test.test_nonConstMapValue); | |
| 1847 }); | |
| 1848 _ut.test('test_uriWithInterpolation_constant', () { | |
| 1849 final __test = new CompileTimeErrorCodeTest(); | |
| 1850 runJUnitTest(__test, __test.test_uriWithInterpolation_constant); | |
| 1851 }); | |
| 1852 _ut.test('test_uriWithInterpolation_nonConstant', () { | |
| 1853 final __test = new CompileTimeErrorCodeTest(); | |
| 1854 runJUnitTest(__test, __test.test_uriWithInterpolation_nonConstant); | |
| 1855 }); | |
| 1856 }); | |
| 1857 } | |
| 1858 } | |
| 1859 /** | |
| 1860 * Instances of the class {@code StaticTypeVerifier} verify that all of the node
s in an AST | |
| 1861 * structure that should have a static type associated with them do have a stati
c type. | |
| 1862 */ | |
| 1863 class StaticTypeVerifier extends GeneralizingASTVisitor<Object> { | |
| 1864 /** | |
| 1865 * A list containing all of the AST Expression nodes that were not resolved. | |
| 1866 */ | |
| 1867 List<Expression> _unresolvedExpressions = new List<Expression>(); | |
| 1868 /** | |
| 1869 * A list containing all of the AST TypeName nodes that were not resolved. | |
| 1870 */ | |
| 1871 List<TypeName> _unresolvedTypes = new List<TypeName>(); | |
| 1872 /** | |
| 1873 * Counter for the number of Expression nodes visited that are resolved. | |
| 1874 */ | |
| 1875 int _resolvedExpressionCount = 0; | |
| 1876 /** | |
| 1877 * Counter for the number of TypeName nodes visited that are resolved. | |
| 1878 */ | |
| 1879 int _resolvedTypeCount = 0; | |
| 1880 /** | |
| 1881 * Initialize a newly created verifier to verify that all of the nodes in an A
ST structure that | |
| 1882 * should have a static type associated with them do have a static type. | |
| 1883 */ | |
| 1884 StaticTypeVerifier() : super() { | |
| 1885 } | |
| 1886 /** | |
| 1887 * Assert that all of the visited nodes have a static type associated with the
m. | |
| 1888 */ | |
| 1889 void assertResolved() { | |
| 1890 if (!_unresolvedExpressions.isEmpty || !_unresolvedTypes.isEmpty) { | |
| 1891 int unresolvedExpressionCount = _unresolvedExpressions.length; | |
| 1892 int unresolvedTypeCount = _unresolvedTypes.length; | |
| 1893 PrintStringWriter writer = new PrintStringWriter(); | |
| 1894 writer.print("Failed to associate types with nodes: "); | |
| 1895 writer.print(unresolvedExpressionCount); | |
| 1896 writer.print("/"); | |
| 1897 writer.print(_resolvedExpressionCount + unresolvedExpressionCount); | |
| 1898 writer.print(" Expressions and "); | |
| 1899 writer.print(unresolvedTypeCount); | |
| 1900 writer.print("/"); | |
| 1901 writer.print(_resolvedTypeCount + unresolvedTypeCount); | |
| 1902 writer.printlnObject(" TypeNames."); | |
| 1903 if (unresolvedTypeCount > 0) { | |
| 1904 writer.printlnObject("TypeNames:"); | |
| 1905 for (TypeName identifier in _unresolvedTypes) { | |
| 1906 writer.print(" "); | |
| 1907 writer.print(identifier.toString()); | |
| 1908 writer.print(" ("); | |
| 1909 writer.print(getFileName(identifier)); | |
| 1910 writer.print(" : "); | |
| 1911 writer.print(identifier.offset); | |
| 1912 writer.printlnObject(")"); | |
| 1913 } | |
| 1914 } | |
| 1915 if (unresolvedExpressionCount > 0) { | |
| 1916 writer.printlnObject("Expressions:"); | |
| 1917 for (Expression identifier in _unresolvedExpressions) { | |
| 1918 writer.print(" "); | |
| 1919 writer.print(identifier.toString()); | |
| 1920 writer.print(" ("); | |
| 1921 writer.print(getFileName(identifier)); | |
| 1922 writer.print(" : "); | |
| 1923 writer.print(identifier.offset); | |
| 1924 writer.printlnObject(")"); | |
| 1925 } | |
| 1926 } | |
| 1927 JUnitTestCase.fail(writer.toString()); | |
| 1928 } | |
| 1929 } | |
| 1930 Object visitCommentReference(CommentReference node) => null; | |
| 1931 Object visitExpression(Expression node) { | |
| 1932 node.visitChildren(this); | |
| 1933 if (node.staticType == null) { | |
| 1934 _unresolvedExpressions.add(node); | |
| 1935 } else { | |
| 1936 _resolvedExpressionCount++; | |
| 1937 } | |
| 1938 return null; | |
| 1939 } | |
| 1940 Object visitLibraryIdentifier(LibraryIdentifier node) => null; | |
| 1941 Object visitPrefixedIdentifier(PrefixedIdentifier node) { | |
| 1942 if (node.staticType == null && identical(node.prefix.staticType, DynamicType
Impl.instance)) { | |
| 1943 return null; | |
| 1944 } | |
| 1945 return super.visitPrefixedIdentifier(node); | |
| 1946 } | |
| 1947 Object visitSimpleIdentifier(SimpleIdentifier node) { | |
| 1948 ASTNode parent19 = node.parent; | |
| 1949 if (parent19 is MethodInvocation && identical(node, ((parent19 as MethodInvo
cation)).methodName)) { | |
| 1950 return null; | |
| 1951 } else if (parent19 is RedirectingConstructorInvocation && identical(node, (
(parent19 as RedirectingConstructorInvocation)).constructorName)) { | |
| 1952 return null; | |
| 1953 } else if (parent19 is SuperConstructorInvocation && identical(node, ((paren
t19 as SuperConstructorInvocation)).constructorName)) { | |
| 1954 return null; | |
| 1955 } else if (parent19 is ConstructorName && identical(node, ((parent19 as Cons
tructorName)).name)) { | |
| 1956 return null; | |
| 1957 } else if (parent19 is Label && identical(node, ((parent19 as Label)).label)
) { | |
| 1958 return null; | |
| 1959 } else if (parent19 is ImportDirective && identical(node, ((parent19 as Impo
rtDirective)).prefix)) { | |
| 1960 return null; | |
| 1961 } else if (node.element is PrefixElement) { | |
| 1962 return null; | |
| 1963 } | |
| 1964 return super.visitSimpleIdentifier(node); | |
| 1965 } | |
| 1966 Object visitTypeName(TypeName node) { | |
| 1967 if (node.type == null) { | |
| 1968 _unresolvedTypes.add(node); | |
| 1969 } else { | |
| 1970 _resolvedTypeCount++; | |
| 1971 } | |
| 1972 return null; | |
| 1973 } | |
| 1974 String getFileName(ASTNode node) { | |
| 1975 if (node != null) { | |
| 1976 ASTNode root3 = node.root; | |
| 1977 if (root3 is CompilationUnit) { | |
| 1978 CompilationUnit rootCU = (root3 as CompilationUnit); | |
| 1979 if (rootCU.element != null) { | |
| 1980 return rootCU.element.source.fullName; | |
| 1981 } else { | |
| 1982 return "<unknown file- CompilationUnit.getElement() returned null>"; | |
| 1983 } | |
| 1984 } else { | |
| 1985 return "<unknown file- CompilationUnit.getRoot() is not a CompilationUni
t>"; | |
| 1986 } | |
| 1987 } | |
| 1988 return "<unknown file- ASTNode is null>"; | |
| 1989 } | |
| 1990 } | |
| 1991 class ElementResolverTest extends EngineTestCase { | |
| 1992 /** | |
| 1993 * The error listener to which errors will be reported. | |
| 1994 */ | |
| 1995 GatheringErrorListener _listener; | |
| 1996 /** | |
| 1997 * The type provider used to access the types. | |
| 1998 */ | |
| 1999 TestTypeProvider _typeProvider; | |
| 2000 /** | |
| 2001 * The library containing the code being resolved. | |
| 2002 */ | |
| 2003 LibraryElementImpl _definingLibrary; | |
| 2004 /** | |
| 2005 * The resolver visitor that maintains the state for the resolver. | |
| 2006 */ | |
| 2007 ResolverVisitor _visitor; | |
| 2008 /** | |
| 2009 * The resolver being used to resolve the test cases. | |
| 2010 */ | |
| 2011 ElementResolver _resolver; | |
| 2012 void fail_visitExportDirective_combinators() { | |
| 2013 JUnitTestCase.fail("Not yet tested"); | |
| 2014 ExportDirective directive = ASTFactory.exportDirective2(null, [ASTFactory.hi
deCombinator2(["A"])]); | |
| 2015 resolveNode(directive, []); | |
| 2016 _listener.assertNoErrors(); | |
| 2017 } | |
| 2018 void fail_visitFunctionExpressionInvocation() { | |
| 2019 JUnitTestCase.fail("Not yet tested"); | |
| 2020 _listener.assertNoErrors(); | |
| 2021 } | |
| 2022 void fail_visitImportDirective_combinators_noPrefix() { | |
| 2023 JUnitTestCase.fail("Not yet tested"); | |
| 2024 ImportDirective directive = ASTFactory.importDirective2(null, null, [ASTFact
ory.showCombinator2(["A"])]); | |
| 2025 resolveNode(directive, []); | |
| 2026 _listener.assertNoErrors(); | |
| 2027 } | |
| 2028 void fail_visitImportDirective_combinators_prefix() { | |
| 2029 JUnitTestCase.fail("Not yet tested"); | |
| 2030 String prefixName = "p"; | |
| 2031 _definingLibrary.imports = <ImportElement> [ElementFactory.importFor(null, E
lementFactory.prefix(prefixName), [])]; | |
| 2032 ImportDirective directive = ASTFactory.importDirective2(null, prefixName, [A
STFactory.showCombinator2(["A"]), ASTFactory.hideCombinator2(["B"])]); | |
| 2033 resolveNode(directive, []); | |
| 2034 _listener.assertNoErrors(); | |
| 2035 } | |
| 2036 void fail_visitRedirectingConstructorInvocation() { | |
| 2037 JUnitTestCase.fail("Not yet tested"); | |
| 2038 _listener.assertNoErrors(); | |
| 2039 } | |
| 2040 void setUp() { | |
| 2041 _listener = new GatheringErrorListener(); | |
| 2042 _typeProvider = new TestTypeProvider(); | |
| 2043 _resolver = createResolver(); | |
| 2044 } | |
| 2045 void test_visitAssignmentExpression_compound() { | |
| 2046 InterfaceType intType2 = _typeProvider.intType; | |
| 2047 SimpleIdentifier leftHandSide = ASTFactory.identifier2("a"); | |
| 2048 leftHandSide.staticType = intType2; | |
| 2049 AssignmentExpression assignment = ASTFactory.assignmentExpression(leftHandSi
de, TokenType.PLUS_EQ, ASTFactory.integer(1)); | |
| 2050 resolveNode(assignment, []); | |
| 2051 JUnitTestCase.assertSame(getMethod(_typeProvider.numType, "+"), assignment.e
lement); | |
| 2052 _listener.assertNoErrors(); | |
| 2053 } | |
| 2054 void test_visitAssignmentExpression_simple() { | |
| 2055 AssignmentExpression expression = ASTFactory.assignmentExpression(ASTFactory
.identifier2("x"), TokenType.EQ, ASTFactory.integer(0)); | |
| 2056 resolveNode(expression, []); | |
| 2057 JUnitTestCase.assertNull(expression.element); | |
| 2058 _listener.assertNoErrors(); | |
| 2059 } | |
| 2060 void test_visitBinaryExpression() { | |
| 2061 InterfaceType numType2 = _typeProvider.numType; | |
| 2062 SimpleIdentifier left = ASTFactory.identifier2("i"); | |
| 2063 left.staticType = numType2; | |
| 2064 BinaryExpression expression = ASTFactory.binaryExpression(left, TokenType.PL
US, ASTFactory.identifier2("j")); | |
| 2065 resolveNode(expression, []); | |
| 2066 JUnitTestCase.assertEquals(getMethod(numType2, "+"), expression.element); | |
| 2067 _listener.assertNoErrors(); | |
| 2068 } | |
| 2069 void test_visitBreakStatement_withLabel() { | |
| 2070 String label = "loop"; | |
| 2071 LabelElementImpl labelElement = new LabelElementImpl(ASTFactory.identifier2(
label), false, false); | |
| 2072 BreakStatement statement = ASTFactory.breakStatement2(label); | |
| 2073 JUnitTestCase.assertSame(labelElement, resolve(statement, labelElement)); | |
| 2074 _listener.assertNoErrors(); | |
| 2075 } | |
| 2076 void test_visitBreakStatement_withoutLabel() { | |
| 2077 BreakStatement statement = ASTFactory.breakStatement(); | |
| 2078 resolveStatement(statement, null); | |
| 2079 _listener.assertNoErrors(); | |
| 2080 } | |
| 2081 void test_visitConstructorName_named() { | |
| 2082 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2083 String constructorName = "a"; | |
| 2084 ConstructorElement constructor = ElementFactory.constructorElement(construct
orName); | |
| 2085 classA.constructors = <ConstructorElement> [constructor]; | |
| 2086 ConstructorName name = ASTFactory.constructorName(ASTFactory.typeName(classA
, []), constructorName); | |
| 2087 resolveNode(name, []); | |
| 2088 JUnitTestCase.assertSame(constructor, name.element); | |
| 2089 _listener.assertNoErrors(); | |
| 2090 } | |
| 2091 void test_visitConstructorName_unnamed() { | |
| 2092 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2093 String constructorName = null; | |
| 2094 ConstructorElement constructor = ElementFactory.constructorElement(construct
orName); | |
| 2095 classA.constructors = <ConstructorElement> [constructor]; | |
| 2096 ConstructorName name = ASTFactory.constructorName(ASTFactory.typeName(classA
, []), constructorName); | |
| 2097 resolveNode(name, []); | |
| 2098 JUnitTestCase.assertSame(constructor, name.element); | |
| 2099 _listener.assertNoErrors(); | |
| 2100 } | |
| 2101 void test_visitContinueStatement_withLabel() { | |
| 2102 String label = "loop"; | |
| 2103 LabelElementImpl labelElement = new LabelElementImpl(ASTFactory.identifier2(
label), false, false); | |
| 2104 ContinueStatement statement = ASTFactory.continueStatement2(label); | |
| 2105 JUnitTestCase.assertSame(labelElement, resolve2(statement, labelElement)); | |
| 2106 _listener.assertNoErrors(); | |
| 2107 } | |
| 2108 void test_visitContinueStatement_withoutLabel() { | |
| 2109 ContinueStatement statement = ASTFactory.continueStatement(); | |
| 2110 resolveStatement(statement, null); | |
| 2111 _listener.assertNoErrors(); | |
| 2112 } | |
| 2113 void test_visitExportDirective_noCombinators() { | |
| 2114 ExportDirective directive = ASTFactory.exportDirective2(null, []); | |
| 2115 directive.element = ElementFactory.exportFor(ElementFactory.library(_definin
gLibrary.context, "lib"), []); | |
| 2116 resolveNode(directive, []); | |
| 2117 _listener.assertNoErrors(); | |
| 2118 } | |
| 2119 void test_visitImportDirective_noCombinators_noPrefix() { | |
| 2120 ImportDirective directive = ASTFactory.importDirective2(null, null, []); | |
| 2121 directive.element = ElementFactory.importFor(ElementFactory.library(_definin
gLibrary.context, "lib"), null, []); | |
| 2122 resolveNode(directive, []); | |
| 2123 _listener.assertNoErrors(); | |
| 2124 } | |
| 2125 void test_visitImportDirective_noCombinators_prefix() { | |
| 2126 String prefixName = "p"; | |
| 2127 ImportElement importElement = ElementFactory.importFor(ElementFactory.librar
y(_definingLibrary.context, "lib"), ElementFactory.prefix(prefixName), []); | |
| 2128 _definingLibrary.imports = <ImportElement> [importElement]; | |
| 2129 ImportDirective directive = ASTFactory.importDirective2(null, prefixName, []
); | |
| 2130 directive.element = importElement; | |
| 2131 resolveNode(directive, []); | |
| 2132 _listener.assertNoErrors(); | |
| 2133 } | |
| 2134 void test_visitIndexExpression_get() { | |
| 2135 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2136 InterfaceType intType3 = _typeProvider.intType; | |
| 2137 MethodElement getter = ElementFactory.methodElement("[]", intType3, [intType
3]); | |
| 2138 classA.methods = <MethodElement> [getter]; | |
| 2139 SimpleIdentifier array = ASTFactory.identifier2("a"); | |
| 2140 array.staticType = classA.type; | |
| 2141 IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.id
entifier2("i")); | |
| 2142 JUnitTestCase.assertSame(getter, resolve4(expression, [])); | |
| 2143 _listener.assertNoErrors(); | |
| 2144 } | |
| 2145 void test_visitIndexExpression_set() { | |
| 2146 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2147 InterfaceType intType4 = _typeProvider.intType; | |
| 2148 MethodElement setter = ElementFactory.methodElement("[]=", intType4, [intTyp
e4]); | |
| 2149 classA.methods = <MethodElement> [setter]; | |
| 2150 SimpleIdentifier array = ASTFactory.identifier2("a"); | |
| 2151 array.staticType = classA.type; | |
| 2152 IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.id
entifier2("i")); | |
| 2153 ASTFactory.assignmentExpression(expression, TokenType.EQ, ASTFactory.integer
(0)); | |
| 2154 JUnitTestCase.assertSame(setter, resolve4(expression, [])); | |
| 2155 _listener.assertNoErrors(); | |
| 2156 } | |
| 2157 void test_visitInstanceCreationExpression_named() { | |
| 2158 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2159 String constructorName = "a"; | |
| 2160 ConstructorElement constructor = ElementFactory.constructorElement(construct
orName); | |
| 2161 classA.constructors = <ConstructorElement> [constructor]; | |
| 2162 ConstructorName name = ASTFactory.constructorName(ASTFactory.typeName(classA
, []), constructorName); | |
| 2163 name.element = constructor; | |
| 2164 InstanceCreationExpression creation = ASTFactory.instanceCreationExpression(
Keyword.NEW, name, []); | |
| 2165 resolveNode(creation, []); | |
| 2166 JUnitTestCase.assertSame(constructor, creation.element); | |
| 2167 _listener.assertNoErrors(); | |
| 2168 } | |
| 2169 void test_visitInstanceCreationExpression_unnamed() { | |
| 2170 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2171 String constructorName = null; | |
| 2172 ConstructorElement constructor = ElementFactory.constructorElement(construct
orName); | |
| 2173 classA.constructors = <ConstructorElement> [constructor]; | |
| 2174 ConstructorName name = ASTFactory.constructorName(ASTFactory.typeName(classA
, []), constructorName); | |
| 2175 name.element = constructor; | |
| 2176 InstanceCreationExpression creation = ASTFactory.instanceCreationExpression(
Keyword.NEW, name, []); | |
| 2177 resolveNode(creation, []); | |
| 2178 JUnitTestCase.assertSame(constructor, creation.element); | |
| 2179 _listener.assertNoErrors(); | |
| 2180 } | |
| 2181 void test_visitInstanceCreationExpression_unnamed_namedParameter() { | |
| 2182 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2183 String constructorName = null; | |
| 2184 ConstructorElementImpl constructor = ElementFactory.constructorElement(const
ructorName); | |
| 2185 String parameterName = "a"; | |
| 2186 ParameterElement parameter = ElementFactory.namedParameter(parameterName); | |
| 2187 constructor.parameters = <ParameterElement> [parameter]; | |
| 2188 classA.constructors = <ConstructorElement> [constructor]; | |
| 2189 ConstructorName name = ASTFactory.constructorName(ASTFactory.typeName(classA
, []), constructorName); | |
| 2190 name.element = constructor; | |
| 2191 InstanceCreationExpression creation = ASTFactory.instanceCreationExpression(
Keyword.NEW, name, [ASTFactory.namedExpression(parameterName, ASTFactory.integer
(0))]); | |
| 2192 resolveNode(creation, []); | |
| 2193 JUnitTestCase.assertSame(constructor, creation.element); | |
| 2194 JUnitTestCase.assertSame(parameter, ((creation.argumentList.arguments[0] as
NamedExpression)).name.label.element); | |
| 2195 _listener.assertNoErrors(); | |
| 2196 } | |
| 2197 void test_visitMethodInvocation() { | |
| 2198 InterfaceType numType3 = _typeProvider.numType; | |
| 2199 SimpleIdentifier left = ASTFactory.identifier2("i"); | |
| 2200 left.staticType = numType3; | |
| 2201 String methodName = "abs"; | |
| 2202 MethodInvocation invocation = ASTFactory.methodInvocation(left, methodName,
[]); | |
| 2203 resolveNode(invocation, []); | |
| 2204 JUnitTestCase.assertSame(getMethod(numType3, methodName), invocation.methodN
ame.element); | |
| 2205 _listener.assertNoErrors(); | |
| 2206 } | |
| 2207 void test_visitMethodInvocation_namedParameter() { | |
| 2208 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2209 String methodName = "m"; | |
| 2210 String parameterName = "p"; | |
| 2211 MethodElementImpl method = ElementFactory.methodElement(methodName, null, []
); | |
| 2212 ParameterElement parameter = ElementFactory.namedParameter(parameterName); | |
| 2213 method.parameters = <ParameterElement> [parameter]; | |
| 2214 classA.methods = <MethodElement> [method]; | |
| 2215 SimpleIdentifier left = ASTFactory.identifier2("i"); | |
| 2216 left.staticType = classA.type; | |
| 2217 MethodInvocation invocation = ASTFactory.methodInvocation(left, methodName,
[ASTFactory.namedExpression(parameterName, ASTFactory.integer(0))]); | |
| 2218 resolveNode(invocation, []); | |
| 2219 JUnitTestCase.assertSame(method, invocation.methodName.element); | |
| 2220 JUnitTestCase.assertSame(parameter, ((invocation.argumentList.arguments[0] a
s NamedExpression)).name.label.element); | |
| 2221 _listener.assertNoErrors(); | |
| 2222 } | |
| 2223 void test_visitPostfixExpression() { | |
| 2224 InterfaceType numType4 = _typeProvider.numType; | |
| 2225 SimpleIdentifier operand = ASTFactory.identifier2("i"); | |
| 2226 operand.staticType = numType4; | |
| 2227 PostfixExpression expression = ASTFactory.postfixExpression(operand, TokenTy
pe.PLUS_PLUS); | |
| 2228 resolveNode(expression, []); | |
| 2229 JUnitTestCase.assertEquals(getMethod(numType4, "+"), expression.element); | |
| 2230 _listener.assertNoErrors(); | |
| 2231 } | |
| 2232 void test_visitPrefixedIdentifier_dynamic() { | |
| 2233 Type2 dynamicType2 = _typeProvider.dynamicType; | |
| 2234 SimpleIdentifier target = ASTFactory.identifier2("a"); | |
| 2235 VariableElementImpl variable = ElementFactory.localVariableElement(target); | |
| 2236 variable.type = dynamicType2; | |
| 2237 target.element = variable; | |
| 2238 target.staticType = dynamicType2; | |
| 2239 PrefixedIdentifier identifier5 = ASTFactory.identifier(target, ASTFactory.id
entifier2("b")); | |
| 2240 resolveNode(identifier5, []); | |
| 2241 JUnitTestCase.assertNull(identifier5.element); | |
| 2242 JUnitTestCase.assertNull(identifier5.identifier.element); | |
| 2243 _listener.assertNoErrors(); | |
| 2244 } | |
| 2245 void test_visitPrefixedIdentifier_nonDynamic() { | |
| 2246 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2247 String getterName = "b"; | |
| 2248 PropertyAccessorElement getter = ElementFactory.getterElement(getterName, fa
lse, _typeProvider.intType); | |
| 2249 classA.accessors = <PropertyAccessorElement> [getter]; | |
| 2250 SimpleIdentifier target = ASTFactory.identifier2("a"); | |
| 2251 VariableElementImpl variable = ElementFactory.localVariableElement(target); | |
| 2252 variable.type = classA.type; | |
| 2253 target.element = variable; | |
| 2254 target.staticType = classA.type; | |
| 2255 PrefixedIdentifier identifier6 = ASTFactory.identifier(target, ASTFactory.id
entifier2(getterName)); | |
| 2256 resolveNode(identifier6, []); | |
| 2257 JUnitTestCase.assertSame(getter, identifier6.element); | |
| 2258 JUnitTestCase.assertSame(getter, identifier6.identifier.element); | |
| 2259 _listener.assertNoErrors(); | |
| 2260 } | |
| 2261 void test_visitPrefixExpression() { | |
| 2262 InterfaceType numType5 = _typeProvider.numType; | |
| 2263 SimpleIdentifier operand = ASTFactory.identifier2("i"); | |
| 2264 operand.staticType = numType5; | |
| 2265 PrefixExpression expression = ASTFactory.prefixExpression(TokenType.PLUS_PLU
S, operand); | |
| 2266 resolveNode(expression, []); | |
| 2267 JUnitTestCase.assertEquals(getMethod(numType5, "+"), expression.element); | |
| 2268 _listener.assertNoErrors(); | |
| 2269 } | |
| 2270 void test_visitPropertyAccess_getter_identifier() { | |
| 2271 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2272 String getterName = "b"; | |
| 2273 PropertyAccessorElement getter = ElementFactory.getterElement(getterName, fa
lse, _typeProvider.intType); | |
| 2274 classA.accessors = <PropertyAccessorElement> [getter]; | |
| 2275 SimpleIdentifier target = ASTFactory.identifier2("a"); | |
| 2276 target.staticType = classA.type; | |
| 2277 PropertyAccess access = ASTFactory.propertyAccess2(target, getterName); | |
| 2278 resolveNode(access, []); | |
| 2279 JUnitTestCase.assertSame(getter, access.propertyName.element); | |
| 2280 _listener.assertNoErrors(); | |
| 2281 } | |
| 2282 void test_visitPropertyAccess_getter_super() { | |
| 2283 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2284 String getterName = "b"; | |
| 2285 PropertyAccessorElement getter = ElementFactory.getterElement(getterName, fa
lse, _typeProvider.intType); | |
| 2286 classA.accessors = <PropertyAccessorElement> [getter]; | |
| 2287 SuperExpression target = ASTFactory.superExpression(); | |
| 2288 target.staticType = classA.type; | |
| 2289 PropertyAccess access = ASTFactory.propertyAccess2(target, getterName); | |
| 2290 resolveNode(access, []); | |
| 2291 JUnitTestCase.assertSame(getter, access.propertyName.element); | |
| 2292 _listener.assertNoErrors(); | |
| 2293 } | |
| 2294 void test_visitPropertyAccess_setter_this() { | |
| 2295 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2296 String setterName = "b"; | |
| 2297 PropertyAccessorElement setter = ElementFactory.setterElement(setterName, fa
lse, _typeProvider.intType); | |
| 2298 classA.accessors = <PropertyAccessorElement> [setter]; | |
| 2299 ThisExpression target = ASTFactory.thisExpression(); | |
| 2300 target.staticType = classA.type; | |
| 2301 PropertyAccess access = ASTFactory.propertyAccess2(target, setterName); | |
| 2302 ASTFactory.assignmentExpression(access, TokenType.EQ, ASTFactory.integer(0))
; | |
| 2303 resolveNode(access, []); | |
| 2304 JUnitTestCase.assertSame(setter, access.propertyName.element); | |
| 2305 _listener.assertNoErrors(); | |
| 2306 } | |
| 2307 void test_visitSimpleIdentifier_classScope() { | |
| 2308 InterfaceType doubleType2 = _typeProvider.doubleType; | |
| 2309 String fieldName = "NAN"; | |
| 2310 SimpleIdentifier node = ASTFactory.identifier2(fieldName); | |
| 2311 resolveInClass(node, doubleType2.element); | |
| 2312 JUnitTestCase.assertEquals(getGetter(doubleType2, fieldName), node.element); | |
| 2313 _listener.assertNoErrors(); | |
| 2314 } | |
| 2315 void test_visitSimpleIdentifier_lexicalScope() { | |
| 2316 SimpleIdentifier node = ASTFactory.identifier2("i"); | |
| 2317 VariableElementImpl element = ElementFactory.localVariableElement(node); | |
| 2318 JUnitTestCase.assertSame(element, resolve3(node, [element])); | |
| 2319 _listener.assertNoErrors(); | |
| 2320 } | |
| 2321 void test_visitSimpleIdentifier_lexicalScope_field_setter() { | |
| 2322 InterfaceType intType5 = _typeProvider.intType; | |
| 2323 ClassElementImpl classA = ElementFactory.classElement2("A", []); | |
| 2324 String fieldName = "a"; | |
| 2325 FieldElement field = ElementFactory.fieldElement(fieldName, false, false, fa
lse, intType5); | |
| 2326 classA.fields = <FieldElement> [field]; | |
| 2327 classA.accessors = <PropertyAccessorElement> [field.getter, field.setter]; | |
| 2328 SimpleIdentifier node = ASTFactory.identifier2(fieldName); | |
| 2329 ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0)); | |
| 2330 resolveInClass(node, classA); | |
| 2331 Element element47 = node.element; | |
| 2332 EngineTestCase.assertInstanceOf(PropertyAccessorElement, element47); | |
| 2333 JUnitTestCase.assertTrue(((element47 as PropertyAccessorElement)).isSetter()
); | |
| 2334 _listener.assertNoErrors(); | |
| 2335 } | |
| 2336 void test_visitSuperConstructorInvocation() { | |
| 2337 ClassElementImpl superclass = ElementFactory.classElement2("A", []); | |
| 2338 ConstructorElementImpl superConstructor = ElementFactory.constructorElement(
null); | |
| 2339 superclass.constructors = <ConstructorElement> [superConstructor]; | |
| 2340 ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type
, []); | |
| 2341 ConstructorElementImpl subConstructor = ElementFactory.constructorElement(nu
ll); | |
| 2342 subclass.constructors = <ConstructorElement> [subConstructor]; | |
| 2343 SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocatio
n([]); | |
| 2344 resolveInClass(invocation, subclass); | |
| 2345 JUnitTestCase.assertEquals(superConstructor, invocation.element); | |
| 2346 _listener.assertNoErrors(); | |
| 2347 } | |
| 2348 void test_visitSuperConstructorInvocation_namedParameter() { | |
| 2349 ClassElementImpl superclass = ElementFactory.classElement2("A", []); | |
| 2350 ConstructorElementImpl superConstructor = ElementFactory.constructorElement(
null); | |
| 2351 String parameterName = "p"; | |
| 2352 ParameterElement parameter = ElementFactory.namedParameter(parameterName); | |
| 2353 superConstructor.parameters = <ParameterElement> [parameter]; | |
| 2354 superclass.constructors = <ConstructorElement> [superConstructor]; | |
| 2355 ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type
, []); | |
| 2356 ConstructorElementImpl subConstructor = ElementFactory.constructorElement(nu
ll); | |
| 2357 subclass.constructors = <ConstructorElement> [subConstructor]; | |
| 2358 SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocatio
n([ASTFactory.namedExpression(parameterName, ASTFactory.integer(0))]); | |
| 2359 resolveInClass(invocation, subclass); | |
| 2360 JUnitTestCase.assertEquals(superConstructor, invocation.element); | |
| 2361 JUnitTestCase.assertSame(parameter, ((invocation.argumentList.arguments[0] a
s NamedExpression)).name.label.element); | |
| 2362 _listener.assertNoErrors(); | |
| 2363 } | |
| 2364 /** | |
| 2365 * Create the resolver used by the tests. | |
| 2366 * @return the resolver that was created | |
| 2367 */ | |
| 2368 ElementResolver createResolver() { | |
| 2369 AnalysisContextImpl context = new AnalysisContextImpl(); | |
| 2370 SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(Da
rtSdk.defaultSdk)]); | |
| 2371 context.sourceFactory = sourceFactory; | |
| 2372 CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElem
entImpl("test.dart"); | |
| 2373 definingCompilationUnit.source = new FileBasedSource.con1(sourceFactory, Fil
eUtilities2.createFile("/test.dart")); | |
| 2374 _definingLibrary = ElementFactory.library(context, "test"); | |
| 2375 _definingLibrary.definingCompilationUnit = definingCompilationUnit; | |
| 2376 Library library = new Library(context, _listener, null); | |
| 2377 library.libraryElement = _definingLibrary; | |
| 2378 _visitor = new ResolverVisitor(library, null, _typeProvider); | |
| 2379 try { | |
| 2380 return _visitor.elementResolver_J2DAccessor as ElementResolver; | |
| 2381 } on JavaException catch (exception) { | |
| 2382 throw new IllegalArgumentException("Could not create resolver", exception)
; | |
| 2383 } | |
| 2384 } | |
| 2385 /** | |
| 2386 * Return the element associated with the label of the given statement after t
he resolver has | |
| 2387 * resolved the statement. | |
| 2388 * @param statement the statement to be resolved | |
| 2389 * @param labelElement the label element to be defined in the statement's labe
l scope | |
| 2390 * @return the element to which the statement's label was resolved | |
| 2391 */ | |
| 2392 Element resolve(BreakStatement statement, LabelElementImpl labelElement) { | |
| 2393 resolveStatement(statement, labelElement); | |
| 2394 return statement.label.element; | |
| 2395 } | |
| 2396 /** | |
| 2397 * Return the element associated with the label of the given statement after t
he resolver has | |
| 2398 * resolved the statement. | |
| 2399 * @param statement the statement to be resolved | |
| 2400 * @param labelElement the label element to be defined in the statement's labe
l scope | |
| 2401 * @return the element to which the statement's label was resolved | |
| 2402 */ | |
| 2403 Element resolve2(ContinueStatement statement, LabelElementImpl labelElement) { | |
| 2404 resolveStatement(statement, labelElement); | |
| 2405 return statement.label.element; | |
| 2406 } | |
| 2407 /** | |
| 2408 * Return the element associated with the given identifier after the resolver
has resolved the | |
| 2409 * identifier. | |
| 2410 * @param node the expression to be resolved | |
| 2411 * @param definedElements the elements that are to be defined in the scope in
which the element is | |
| 2412 * being resolved | |
| 2413 * @return the element to which the expression was resolved | |
| 2414 */ | |
| 2415 Element resolve3(Identifier node, List<Element> definedElements) { | |
| 2416 resolveNode(node, definedElements); | |
| 2417 return node.element; | |
| 2418 } | |
| 2419 /** | |
| 2420 * Return the element associated with the given expression after the resolver
has resolved the | |
| 2421 * expression. | |
| 2422 * @param node the expression to be resolved | |
| 2423 * @param definedElements the elements that are to be defined in the scope in
which the element is | |
| 2424 * being resolved | |
| 2425 * @return the element to which the expression was resolved | |
| 2426 */ | |
| 2427 Element resolve4(IndexExpression node, List<Element> definedElements) { | |
| 2428 resolveNode(node, definedElements); | |
| 2429 return node.element; | |
| 2430 } | |
| 2431 /** | |
| 2432 * Return the element associated with the given identifier after the resolver
has resolved the | |
| 2433 * identifier. | |
| 2434 * @param node the expression to be resolved | |
| 2435 * @param enclosingClass the element representing the class enclosing the iden
tifier | |
| 2436 * @return the element to which the expression was resolved | |
| 2437 */ | |
| 2438 void resolveInClass(ASTNode node, ClassElement enclosingClass) { | |
| 2439 try { | |
| 2440 Scope outerScope = _visitor.nameScope_J2DAccessor as Scope; | |
| 2441 try { | |
| 2442 _visitor.enclosingClass_J2DAccessor = enclosingClass; | |
| 2443 EnclosedScope innerScope = new ClassScope(outerScope, enclosingClass); | |
| 2444 _visitor.nameScope_J2DAccessor = innerScope; | |
| 2445 node.accept(_resolver); | |
| 2446 } finally { | |
| 2447 _visitor.enclosingClass_J2DAccessor = null; | |
| 2448 _visitor.nameScope_J2DAccessor = outerScope; | |
| 2449 } | |
| 2450 } on JavaException catch (exception) { | |
| 2451 throw new IllegalArgumentException("Could not resolve node", exception); | |
| 2452 } | |
| 2453 } | |
| 2454 /** | |
| 2455 * Return the element associated with the given identifier after the resolver
has resolved the | |
| 2456 * identifier. | |
| 2457 * @param node the expression to be resolved | |
| 2458 * @param definedElements the elements that are to be defined in the scope in
which the element is | |
| 2459 * being resolved | |
| 2460 * @return the element to which the expression was resolved | |
| 2461 */ | |
| 2462 void resolveNode(ASTNode node, List<Element> definedElements) { | |
| 2463 try { | |
| 2464 Scope outerScope = _visitor.nameScope_J2DAccessor as Scope; | |
| 2465 try { | |
| 2466 EnclosedScope innerScope = new EnclosedScope(outerScope); | |
| 2467 for (Element element in definedElements) { | |
| 2468 innerScope.define(element); | |
| 2469 } | |
| 2470 _visitor.nameScope_J2DAccessor = innerScope; | |
| 2471 node.accept(_resolver); | |
| 2472 } finally { | |
| 2473 _visitor.nameScope_J2DAccessor = outerScope; | |
| 2474 } | |
| 2475 } on JavaException catch (exception) { | |
| 2476 throw new IllegalArgumentException("Could not resolve node", exception); | |
| 2477 } | |
| 2478 } | |
| 2479 /** | |
| 2480 * Return the element associated with the label of the given statement after t
he resolver has | |
| 2481 * resolved the statement. | |
| 2482 * @param statement the statement to be resolved | |
| 2483 * @param labelElement the label element to be defined in the statement's labe
l scope | |
| 2484 * @return the element to which the statement's label was resolved | |
| 2485 */ | |
| 2486 void resolveStatement(Statement statement, LabelElementImpl labelElement) { | |
| 2487 try { | |
| 2488 LabelScope outerScope = _visitor.labelScope_J2DAccessor as LabelScope; | |
| 2489 try { | |
| 2490 LabelScope innerScope; | |
| 2491 if (labelElement == null) { | |
| 2492 innerScope = new LabelScope.con1(outerScope, false, false); | |
| 2493 } else { | |
| 2494 innerScope = new LabelScope.con2(outerScope, labelElement.name, labelE
lement); | |
| 2495 } | |
| 2496 _visitor.labelScope_J2DAccessor = innerScope; | |
| 2497 statement.accept(_resolver); | |
| 2498 } finally { | |
| 2499 _visitor.labelScope_J2DAccessor = outerScope; | |
| 2500 } | |
| 2501 } on JavaException catch (exception) { | |
| 2502 throw new IllegalArgumentException("Could not resolve node", exception); | |
| 2503 } | |
| 2504 } | |
| 2505 static dartSuite() { | |
| 2506 _ut.group('ElementResolverTest', () { | |
| 2507 _ut.test('test_visitAssignmentExpression_compound', () { | |
| 2508 final __test = new ElementResolverTest(); | |
| 2509 runJUnitTest(__test, __test.test_visitAssignmentExpression_compound); | |
| 2510 }); | |
| 2511 _ut.test('test_visitAssignmentExpression_simple', () { | |
| 2512 final __test = new ElementResolverTest(); | |
| 2513 runJUnitTest(__test, __test.test_visitAssignmentExpression_simple); | |
| 2514 }); | |
| 2515 _ut.test('test_visitBinaryExpression', () { | |
| 2516 final __test = new ElementResolverTest(); | |
| 2517 runJUnitTest(__test, __test.test_visitBinaryExpression); | |
| 2518 }); | |
| 2519 _ut.test('test_visitBreakStatement_withLabel', () { | |
| 2520 final __test = new ElementResolverTest(); | |
| 2521 runJUnitTest(__test, __test.test_visitBreakStatement_withLabel); | |
| 2522 }); | |
| 2523 _ut.test('test_visitBreakStatement_withoutLabel', () { | |
| 2524 final __test = new ElementResolverTest(); | |
| 2525 runJUnitTest(__test, __test.test_visitBreakStatement_withoutLabel); | |
| 2526 }); | |
| 2527 _ut.test('test_visitConstructorName_named', () { | |
| 2528 final __test = new ElementResolverTest(); | |
| 2529 runJUnitTest(__test, __test.test_visitConstructorName_named); | |
| 2530 }); | |
| 2531 _ut.test('test_visitConstructorName_unnamed', () { | |
| 2532 final __test = new ElementResolverTest(); | |
| 2533 runJUnitTest(__test, __test.test_visitConstructorName_unnamed); | |
| 2534 }); | |
| 2535 _ut.test('test_visitContinueStatement_withLabel', () { | |
| 2536 final __test = new ElementResolverTest(); | |
| 2537 runJUnitTest(__test, __test.test_visitContinueStatement_withLabel); | |
| 2538 }); | |
| 2539 _ut.test('test_visitContinueStatement_withoutLabel', () { | |
| 2540 final __test = new ElementResolverTest(); | |
| 2541 runJUnitTest(__test, __test.test_visitContinueStatement_withoutLabel); | |
| 2542 }); | |
| 2543 _ut.test('test_visitExportDirective_noCombinators', () { | |
| 2544 final __test = new ElementResolverTest(); | |
| 2545 runJUnitTest(__test, __test.test_visitExportDirective_noCombinators); | |
| 2546 }); | |
| 2547 _ut.test('test_visitImportDirective_noCombinators_noPrefix', () { | |
| 2548 final __test = new ElementResolverTest(); | |
| 2549 runJUnitTest(__test, __test.test_visitImportDirective_noCombinators_noPr
efix); | |
| 2550 }); | |
| 2551 _ut.test('test_visitImportDirective_noCombinators_prefix', () { | |
| 2552 final __test = new ElementResolverTest(); | |
| 2553 runJUnitTest(__test, __test.test_visitImportDirective_noCombinators_pref
ix); | |
| 2554 }); | |
| 2555 _ut.test('test_visitIndexExpression_get', () { | |
| 2556 final __test = new ElementResolverTest(); | |
| 2557 runJUnitTest(__test, __test.test_visitIndexExpression_get); | |
| 2558 }); | |
| 2559 _ut.test('test_visitIndexExpression_set', () { | |
| 2560 final __test = new ElementResolverTest(); | |
| 2561 runJUnitTest(__test, __test.test_visitIndexExpression_set); | |
| 2562 }); | |
| 2563 _ut.test('test_visitInstanceCreationExpression_named', () { | |
| 2564 final __test = new ElementResolverTest(); | |
| 2565 runJUnitTest(__test, __test.test_visitInstanceCreationExpression_named); | |
| 2566 }); | |
| 2567 _ut.test('test_visitInstanceCreationExpression_unnamed', () { | |
| 2568 final __test = new ElementResolverTest(); | |
| 2569 runJUnitTest(__test, __test.test_visitInstanceCreationExpression_unnamed
); | |
| 2570 }); | |
| 2571 _ut.test('test_visitInstanceCreationExpression_unnamed_namedParameter', ()
{ | |
| 2572 final __test = new ElementResolverTest(); | |
| 2573 runJUnitTest(__test, __test.test_visitInstanceCreationExpression_unnamed
_namedParameter); | |
| 2574 }); | |
| 2575 _ut.test('test_visitMethodInvocation', () { | |
| 2576 final __test = new ElementResolverTest(); | |
| 2577 runJUnitTest(__test, __test.test_visitMethodInvocation); | |
| 2578 }); | |
| 2579 _ut.test('test_visitMethodInvocation_namedParameter', () { | |
| 2580 final __test = new ElementResolverTest(); | |
| 2581 runJUnitTest(__test, __test.test_visitMethodInvocation_namedParameter); | |
| 2582 }); | |
| 2583 _ut.test('test_visitPostfixExpression', () { | |
| 2584 final __test = new ElementResolverTest(); | |
| 2585 runJUnitTest(__test, __test.test_visitPostfixExpression); | |
| 2586 }); | |
| 2587 _ut.test('test_visitPrefixExpression', () { | |
| 2588 final __test = new ElementResolverTest(); | |
| 2589 runJUnitTest(__test, __test.test_visitPrefixExpression); | |
| 2590 }); | |
| 2591 _ut.test('test_visitPrefixedIdentifier_dynamic', () { | |
| 2592 final __test = new ElementResolverTest(); | |
| 2593 runJUnitTest(__test, __test.test_visitPrefixedIdentifier_dynamic); | |
| 2594 }); | |
| 2595 _ut.test('test_visitPrefixedIdentifier_nonDynamic', () { | |
| 2596 final __test = new ElementResolverTest(); | |
| 2597 runJUnitTest(__test, __test.test_visitPrefixedIdentifier_nonDynamic); | |
| 2598 }); | |
| 2599 _ut.test('test_visitPropertyAccess_getter_identifier', () { | |
| 2600 final __test = new ElementResolverTest(); | |
| 2601 runJUnitTest(__test, __test.test_visitPropertyAccess_getter_identifier); | |
| 2602 }); | |
| 2603 _ut.test('test_visitPropertyAccess_getter_super', () { | |
| 2604 final __test = new ElementResolverTest(); | |
| 2605 runJUnitTest(__test, __test.test_visitPropertyAccess_getter_super); | |
| 2606 }); | |
| 2607 _ut.test('test_visitPropertyAccess_setter_this', () { | |
| 2608 final __test = new ElementResolverTest(); | |
| 2609 runJUnitTest(__test, __test.test_visitPropertyAccess_setter_this); | |
| 2610 }); | |
| 2611 _ut.test('test_visitSimpleIdentifier_classScope', () { | |
| 2612 final __test = new ElementResolverTest(); | |
| 2613 runJUnitTest(__test, __test.test_visitSimpleIdentifier_classScope); | |
| 2614 }); | |
| 2615 _ut.test('test_visitSimpleIdentifier_lexicalScope', () { | |
| 2616 final __test = new ElementResolverTest(); | |
| 2617 runJUnitTest(__test, __test.test_visitSimpleIdentifier_lexicalScope); | |
| 2618 }); | |
| 2619 _ut.test('test_visitSimpleIdentifier_lexicalScope_field_setter', () { | |
| 2620 final __test = new ElementResolverTest(); | |
| 2621 runJUnitTest(__test, __test.test_visitSimpleIdentifier_lexicalScope_fiel
d_setter); | |
| 2622 }); | |
| 2623 _ut.test('test_visitSuperConstructorInvocation', () { | |
| 2624 final __test = new ElementResolverTest(); | |
| 2625 runJUnitTest(__test, __test.test_visitSuperConstructorInvocation); | |
| 2626 }); | |
| 2627 _ut.test('test_visitSuperConstructorInvocation_namedParameter', () { | |
| 2628 final __test = new ElementResolverTest(); | |
| 2629 runJUnitTest(__test, __test.test_visitSuperConstructorInvocation_namedPa
rameter); | |
| 2630 }); | |
| 2631 }); | |
| 2632 } | |
| 2633 } | |
| 2634 class StaticWarningCodeTest extends ResolverTestCase { | |
| 2635 void fail_argumentTypeNotAssignable() { | |
| 2636 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2637 resolve(source, []); | |
| 2638 assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]); | |
| 2639 verify([source]); | |
| 2640 } | |
| 2641 void fail_assignmentToFinal() { | |
| 2642 Source source = addSource("/test.dart", EngineTestCase.createSource(["final
x = 0;", "f() { x = 1; }"])); | |
| 2643 resolve(source, []); | |
| 2644 assertErrors([StaticWarningCode.ASSIGNMENT_TO_FINAL]); | |
| 2645 verify([source]); | |
| 2646 } | |
| 2647 void fail_caseBlockNotTerminated() { | |
| 2648 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int
p) {", " switch (p) {", " case 0:", " f(p);", " case 1:", " bre
ak;", " }", "}"])); | |
| 2649 resolve(source, []); | |
| 2650 assertErrors([StaticWarningCode.CASE_BLOCK_NOT_TERMINATED]); | |
| 2651 verify([source]); | |
| 2652 } | |
| 2653 void fail_castToNonType() { | |
| 2654 Source source = addSource("/test.dart", EngineTestCase.createSource(["var A
= 0;", "f(String s) { var x = s as A; }"])); | |
| 2655 resolve(source, []); | |
| 2656 assertErrors([StaticWarningCode.CAST_TO_NON_TYPE]); | |
| 2657 verify([source]); | |
| 2658 } | |
| 2659 void fail_commentReferenceConstructorNotVisible() { | |
| 2660 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2661 resolve(source, []); | |
| 2662 assertErrors([StaticWarningCode.COMMENT_REFERENCE_CONSTRUCTOR_NOT_VISIBLE]); | |
| 2663 verify([source]); | |
| 2664 } | |
| 2665 void fail_commentReferenceIdentifierNotVisible() { | |
| 2666 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2667 resolve(source, []); | |
| 2668 assertErrors([StaticWarningCode.COMMENT_REFERENCE_IDENTIFIER_NOT_VISIBLE]); | |
| 2669 verify([source]); | |
| 2670 } | |
| 2671 void fail_commentReferenceUndeclaredConstructor() { | |
| 2672 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2673 resolve(source, []); | |
| 2674 assertErrors([StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_CONSTRUCTOR]); | |
| 2675 verify([source]); | |
| 2676 } | |
| 2677 void fail_commentReferenceUndeclaredIdentifier() { | |
| 2678 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2679 resolve(source, []); | |
| 2680 assertErrors([StaticWarningCode.COMMENT_REFERENCE_UNDECLARED_IDENTIFIER]); | |
| 2681 verify([source]); | |
| 2682 } | |
| 2683 void fail_commentReferenceUriNotLibrary() { | |
| 2684 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2685 resolve(source, []); | |
| 2686 assertErrors([StaticWarningCode.COMMENT_REFERENCE_URI_NOT_LIBRARY]); | |
| 2687 verify([source]); | |
| 2688 } | |
| 2689 void fail_concreteClassWithAbstractMember() { | |
| 2690 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m();", "}"])); | |
| 2691 resolve(source, []); | |
| 2692 assertErrors([StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER]); | |
| 2693 verify([source]); | |
| 2694 } | |
| 2695 void fail_conflictingInstanceGetterAndSuperclassMember() { | |
| 2696 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2697 resolve(source, []); | |
| 2698 assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_M
EMBER]); | |
| 2699 verify([source]); | |
| 2700 } | |
| 2701 void fail_conflictingInstanceSetterAndSuperclassMember() { | |
| 2702 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2703 resolve(source, []); | |
| 2704 assertErrors([StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_M
EMBER]); | |
| 2705 verify([source]); | |
| 2706 } | |
| 2707 void fail_conflictingStaticGetterAndInstanceSetter() { | |
| 2708 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static get x -> 0;", " set x(int p) {}", "}"])); | |
| 2709 resolve(source, []); | |
| 2710 assertErrors([StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTE
R]); | |
| 2711 verify([source]); | |
| 2712 } | |
| 2713 void fail_conflictingStaticSetterAndInstanceGetter() { | |
| 2714 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " get x -> 0;", " static set x(int p) {}", "}"])); | |
| 2715 resolve(source, []); | |
| 2716 assertErrors([StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_GETTE
R]); | |
| 2717 verify([source]); | |
| 2718 } | |
| 2719 void fail_fieldInitializerWithInvalidType() { | |
| 2720 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int x;", " A(String this.x) {}", "}"])); | |
| 2721 resolve(source, []); | |
| 2722 assertErrors([StaticWarningCode.FIELD_INITIALIZER_WITH_INVALID_TYPE]); | |
| 2723 verify([source]); | |
| 2724 } | |
| 2725 void fail_incorrectNumberOfArguments_tooFew() { | |
| 2726 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a, b
) -> 0;", "g() {", " f(2);", "}"])); | |
| 2727 resolve(source, []); | |
| 2728 assertErrors([StaticWarningCode.INCORRECT_NUMBER_OF_ARGUMENTS]); | |
| 2729 verify([source]); | |
| 2730 } | |
| 2731 void fail_incorrectNumberOfArguments_tooMany() { | |
| 2732 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a, b
) -> 0;", "g() {", " f(2, 3, 4);", "}"])); | |
| 2733 resolve(source, []); | |
| 2734 assertErrors([StaticWarningCode.INCORRECT_NUMBER_OF_ARGUMENTS]); | |
| 2735 verify([source]); | |
| 2736 } | |
| 2737 void fail_instanceMethodNameCollidesWithSuperclassStatic() { | |
| 2738 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static n", "}", "class C extends A {", " void n() {}", "}"])); | |
| 2739 resolve(source, []); | |
| 2740 assertErrors([StaticWarningCode.INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLAS
S_STATIC]); | |
| 2741 verify([source]); | |
| 2742 } | |
| 2743 void fail_invalidFactoryName() { | |
| 2744 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2745 resolve(source, []); | |
| 2746 assertErrors([StaticWarningCode.INVALID_FACTORY_NAME]); | |
| 2747 verify([source]); | |
| 2748 } | |
| 2749 void fail_invalidOverrideGetterType() { | |
| 2750 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int get g -> 0", "}", "class B extends A {", " String get g { return '
a'; }", "}"])); | |
| 2751 resolve(source, []); | |
| 2752 assertErrors([StaticWarningCode.INVALID_OVERRIDE_GETTER_TYPE]); | |
| 2753 verify([source]); | |
| 2754 } | |
| 2755 void fail_invalidOverrideReturnType() { | |
| 2756 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int m() { return 0; }", "}", "class B extends A {", " String m() { ret
urn 'a'; }", "}"])); | |
| 2757 resolve(source, []); | |
| 2758 assertErrors([StaticWarningCode.INVALID_OVERRIDE_RETURN_TYPE]); | |
| 2759 verify([source]); | |
| 2760 } | |
| 2761 void fail_invalidOverrideSetterReturnType() { | |
| 2762 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " void set s(int v) {}", "}", "class B extends A {", " void set s(String
v) {}", "}"])); | |
| 2763 resolve(source, []); | |
| 2764 assertErrors([StaticWarningCode.INVALID_OVERRIDE_SETTER_RETURN_TYPE]); | |
| 2765 verify([source]); | |
| 2766 } | |
| 2767 void fail_invocationOfNonFunction() { | |
| 2768 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2769 resolve(source, []); | |
| 2770 assertErrors([StaticWarningCode.INVOCATION_OF_NON_FUNCTION]); | |
| 2771 verify([source]); | |
| 2772 } | |
| 2773 void fail_mismatchedGetterAndSetterTypes() { | |
| 2774 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int get g { return 0; }", " set g(String v) {}", "}"])); | |
| 2775 resolve(source, []); | |
| 2776 assertErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]); | |
| 2777 verify([source]); | |
| 2778 } | |
| 2779 void fail_newWithNonType() { | |
| 2780 Source source = addSource("/test.dart", EngineTestCase.createSource(["var A
= 0;", "void f() {", " A a = new A();", "}"])); | |
| 2781 resolve(source, []); | |
| 2782 assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]); | |
| 2783 verify([source]); | |
| 2784 } | |
| 2785 void fail_newWithUndefinedConstructor() { | |
| 2786 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A(int p) {}", "}", "A f() {", " return new A();", "}"])); | |
| 2787 resolve(source, []); | |
| 2788 assertErrors([StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR]); | |
| 2789 verify([source]); | |
| 2790 } | |
| 2791 void fail_nonAbstractClassInheritsAbstractMember() { | |
| 2792 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
I {", " m(p) {}", "}", "class C implements I {", "}"])); | |
| 2793 resolve(source, []); | |
| 2794 assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER]
); | |
| 2795 verify([source]); | |
| 2796 } | |
| 2797 void fail_nonAbstractClassInheritsAbstractMethod() { | |
| 2798 Source source = addSource("/test.dart", EngineTestCase.createSource(["abstra
ct class A {", " m(p);", "}", "class C extends A {", "}"])); | |
| 2799 resolve(source, []); | |
| 2800 assertErrors([StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_METHOD]
); | |
| 2801 verify([source]); | |
| 2802 } | |
| 2803 void fail_nonType() { | |
| 2804 Source source = addSource("/test.dart", EngineTestCase.createSource(["var A
= 0;", "f(var p) {", " if (p is A) {", " }", "}"])); | |
| 2805 resolve(source, []); | |
| 2806 assertErrors([StaticWarningCode.NON_TYPE]); | |
| 2807 verify([source]); | |
| 2808 } | |
| 2809 void fail_nonTypeInCatchClause() { | |
| 2810 Source source = addSource("/test.dart", EngineTestCase.createSource(["var T
= 0;", "f(var p) {", " try {", " } on T catch e {", " }", "}"])); | |
| 2811 resolve(source, []); | |
| 2812 assertErrors([StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]); | |
| 2813 verify([source]); | |
| 2814 } | |
| 2815 void fail_nonVoidReturnForOperator() { | |
| 2816 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int operator []=() {}", "}"])); | |
| 2817 resolve(source, []); | |
| 2818 assertErrors([StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR]); | |
| 2819 verify([source]); | |
| 2820 } | |
| 2821 void fail_nonVoidReturnForSetter() { | |
| 2822 Source source = addSource("/test.dart", EngineTestCase.createSource(["int se
t x(int v) {", " var s = x;", " x = v;", " return s;", "}"])); | |
| 2823 resolve(source, []); | |
| 2824 assertErrors([StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]); | |
| 2825 verify([source]); | |
| 2826 } | |
| 2827 void fail_overrideNotSubtype() { | |
| 2828 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int m() {}", "}", "class B extends A {", " String m() {}", "}"])); | |
| 2829 resolve(source, []); | |
| 2830 assertErrors([StaticWarningCode.OVERRIDE_NOT_SUBTYPE]); | |
| 2831 verify([source]); | |
| 2832 } | |
| 2833 void fail_overrideWithDifferentDefault() { | |
| 2834 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " m([int p = 0]) {}", "}", "class B extends A {", " m([int p = 1]) {}",
"}"])); | |
| 2835 resolve(source, []); | |
| 2836 assertErrors([StaticWarningCode.OVERRIDE_WITH_DIFFERENT_DEFAULT]); | |
| 2837 verify([source]); | |
| 2838 } | |
| 2839 void fail_redirectToInvalidReturnType() { | |
| 2840 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2841 resolve(source, []); | |
| 2842 assertErrors([StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE]); | |
| 2843 verify([source]); | |
| 2844 } | |
| 2845 void fail_redirectToMissingConstructor() { | |
| 2846 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2847 resolve(source, []); | |
| 2848 assertErrors([StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR]); | |
| 2849 verify([source]); | |
| 2850 } | |
| 2851 void fail_redirectToNonClass() { | |
| 2852 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2853 resolve(source, []); | |
| 2854 assertErrors([StaticWarningCode.REDIRECT_TO_NON_CLASS]); | |
| 2855 verify([source]); | |
| 2856 } | |
| 2857 void fail_returnWithoutValue() { | |
| 2858 Source source = addSource("/test.dart", EngineTestCase.createSource(["int f(
) { return; }"])); | |
| 2859 resolve(source, []); | |
| 2860 assertErrors([StaticWarningCode.RETURN_WITHOUT_VALUE]); | |
| 2861 verify([source]); | |
| 2862 } | |
| 2863 void fail_switchExpressionNotAssignable() { | |
| 2864 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int
p) {", " switch (p) {", " case 'a': break;", " }", "}"])); | |
| 2865 resolve(source, []); | |
| 2866 assertErrors([StaticWarningCode.SWITCH_EXPRESSION_NOT_ASSIGNABLE]); | |
| 2867 verify([source]); | |
| 2868 } | |
| 2869 void fail_undefinedClass() { | |
| 2870 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {
C.m(); }"])); | |
| 2871 resolve(source, []); | |
| 2872 assertErrors([StaticWarningCode.UNDEFINED_CLASS]); | |
| 2873 verify([source]); | |
| 2874 } | |
| 2875 void fail_undefinedGetter() { | |
| 2876 Source source = addSource("/test.dart", EngineTestCase.createSource([])); | |
| 2877 resolve(source, []); | |
| 2878 assertErrors([StaticWarningCode.UNDEFINED_GETTER]); | |
| 2879 verify([source]); | |
| 2880 } | |
| 2881 void fail_undefinedIdentifier_function() { | |
| 2882 Source source = addSource("/test.dart", EngineTestCase.createSource(["int a(
) -> b;"])); | |
| 2883 resolve(source, []); | |
| 2884 assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]); | |
| 2885 verify([source]); | |
| 2886 } | |
| 2887 void fail_undefinedIdentifier_initializer() { | |
| 2888 Source source = addSource("/test.dart", EngineTestCase.createSource(["var a
= b;"])); | |
| 2889 resolve(source, []); | |
| 2890 assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]); | |
| 2891 verify([source]); | |
| 2892 } | |
| 2893 void fail_undefinedSetter() { | |
| 2894 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
C {}", "f(var p) {", " C.m = 0;", "}"])); | |
| 2895 resolve(source, []); | |
| 2896 assertErrors([StaticWarningCode.UNDEFINED_SETTER]); | |
| 2897 verify([source]); | |
| 2898 } | |
| 2899 void fail_undefinedStaticMethodOrGetter_getter() { | |
| 2900 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
C {}", "f(var p) {", " f(C.m);", "}"])); | |
| 2901 resolve(source, []); | |
| 2902 assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]); | |
| 2903 verify([source]); | |
| 2904 } | |
| 2905 void fail_undefinedStaticMethodOrGetter_method() { | |
| 2906 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
C {}", "f(var p) {", " f(C.m());", "}"])); | |
| 2907 resolve(source, []); | |
| 2908 assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]); | |
| 2909 verify([source]); | |
| 2910 } | |
| 2911 void test_constWithAbstractClass() { | |
| 2912 Source source = addSource("/test.dart", EngineTestCase.createSource(["abstra
ct class A {}", "void f() {", " A a = const A();", "}"])); | |
| 2913 resolve(source, []); | |
| 2914 assertErrors([StaticWarningCode.CONST_WITH_ABSTRACT_CLASS]); | |
| 2915 verify([source]); | |
| 2916 } | |
| 2917 void test_equalKeysInMap() { | |
| 2918 Source source = addSource("/test.dart", EngineTestCase.createSource(["var m
= {'a' : 0, 'b' : 1, 'a' : 2};"])); | |
| 2919 resolve(source, []); | |
| 2920 assertErrors([StaticWarningCode.EQUAL_KEYS_IN_MAP]); | |
| 2921 verify([source]); | |
| 2922 } | |
| 2923 void test_newWithAbstractClass() { | |
| 2924 Source source = addSource("/test.dart", EngineTestCase.createSource(["abstra
ct class A {}", "void f() {", " A a = new A();", "}"])); | |
| 2925 resolve(source, []); | |
| 2926 assertErrors([StaticWarningCode.NEW_WITH_ABSTRACT_CLASS]); | |
| 2927 verify([source]); | |
| 2928 } | |
| 2929 void test_partOfDifferentLibrary() { | |
| 2930 Source source = addSource("/test.dart", EngineTestCase.createSource(["librar
y lib;", "part 'part.dart';"])); | |
| 2931 addSource("/part.dart", EngineTestCase.createSource(["part of lub;"])); | |
| 2932 resolve(source, []); | |
| 2933 assertErrors([StaticWarningCode.PART_OF_DIFFERENT_LIBRARY]); | |
| 2934 verify([source]); | |
| 2935 } | |
| 2936 static dartSuite() { | |
| 2937 _ut.group('StaticWarningCodeTest', () { | |
| 2938 _ut.test('test_constWithAbstractClass', () { | |
| 2939 final __test = new StaticWarningCodeTest(); | |
| 2940 runJUnitTest(__test, __test.test_constWithAbstractClass); | |
| 2941 }); | |
| 2942 _ut.test('test_equalKeysInMap', () { | |
| 2943 final __test = new StaticWarningCodeTest(); | |
| 2944 runJUnitTest(__test, __test.test_equalKeysInMap); | |
| 2945 }); | |
| 2946 _ut.test('test_newWithAbstractClass', () { | |
| 2947 final __test = new StaticWarningCodeTest(); | |
| 2948 runJUnitTest(__test, __test.test_newWithAbstractClass); | |
| 2949 }); | |
| 2950 _ut.test('test_partOfDifferentLibrary', () { | |
| 2951 final __test = new StaticWarningCodeTest(); | |
| 2952 runJUnitTest(__test, __test.test_partOfDifferentLibrary); | |
| 2953 }); | |
| 2954 }); | |
| 2955 } | |
| 2956 } | |
| 2957 class ErrorResolverTest extends ResolverTestCase { | |
| 2958 void test_breakLabelOnSwitchMember() { | |
| 2959 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " void m(int i) {", " switch (i) {", " l: case 0:", " brea
k;", " case 1:", " break l;", " }", " }", "}"])); | |
| 2960 resolve(source, []); | |
| 2961 assertErrors([ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]); | |
| 2962 verify([source]); | |
| 2963 } | |
| 2964 void test_continueLabelOnSwitch() { | |
| 2965 Source source = addSource("/a.dart", EngineTestCase.createSource(["class A {
", " void m(int i) {", " l: switch (i) {", " case 0:", " continu
e l;", " }", " }", "}"])); | |
| 2966 resolve(source, []); | |
| 2967 assertErrors([ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]); | |
| 2968 verify([source]); | |
| 2969 } | |
| 2970 static dartSuite() { | |
| 2971 _ut.group('ErrorResolverTest', () { | |
| 2972 _ut.test('test_breakLabelOnSwitchMember', () { | |
| 2973 final __test = new ErrorResolverTest(); | |
| 2974 runJUnitTest(__test, __test.test_breakLabelOnSwitchMember); | |
| 2975 }); | |
| 2976 _ut.test('test_continueLabelOnSwitch', () { | |
| 2977 final __test = new ErrorResolverTest(); | |
| 2978 runJUnitTest(__test, __test.test_continueLabelOnSwitch); | |
| 2979 }); | |
| 2980 }); | |
| 2981 } | |
| 2982 } | |
| 2983 /** | |
| 2984 * The class {@code AnalysisContextFactory} defines utility methods used to crea
te analysis contexts | |
| 2985 * for testing purposes. | |
| 2986 */ | |
| 2987 class AnalysisContextFactory { | |
| 2988 /** | |
| 2989 * Create an analysis context that has a fake core library already resolved. | |
| 2990 * @return the analysis context that was created | |
| 2991 */ | |
| 2992 static AnalysisContextImpl contextWithCore() { | |
| 2993 AnalysisContextImpl context = new AnalysisContextImpl(); | |
| 2994 SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(Da
rtSdk.defaultSdk), new FileUriResolver()]); | |
| 2995 context.sourceFactory = sourceFactory; | |
| 2996 TestTypeProvider provider = new TestTypeProvider(); | |
| 2997 CompilationUnitElementImpl unit = new CompilationUnitElementImpl("core.dart"
); | |
| 2998 unit.types = <ClassElement> [provider.boolType.element, provider.doubleType.
element, provider.functionType.element, provider.intType.element, provider.listT
ype.element, provider.mapType.element, provider.numType.element, provider.object
Type.element, provider.stackTraceType.element, provider.stringType.element, prov
ider.typeType.element]; | |
| 2999 LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libr
aryIdentifier2(["dart", "core"])); | |
| 3000 library.definingCompilationUnit = unit; | |
| 3001 Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>(); | |
| 3002 Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE); | |
| 3003 elementMap[coreSource] = library; | |
| 3004 context.recordLibraryElements(elementMap); | |
| 3005 unit.source = coreSource; | |
| 3006 return context; | |
| 3007 } | |
| 3008 /** | |
| 3009 * Prevent the creation of instances of this class. | |
| 3010 */ | |
| 3011 AnalysisContextFactory() { | |
| 3012 } | |
| 3013 } | |
| 3014 /** | |
| 3015 * Instances of the class {@code TestTypeProvider} implement a type provider tha
t can be used by | |
| 3016 * tests without creating the element model for the core library. | |
| 3017 */ | |
| 3018 class TestTypeProvider implements TypeProvider { | |
| 3019 /** | |
| 3020 * The type representing the built-in type 'bool'. | |
| 3021 */ | |
| 3022 InterfaceType _boolType; | |
| 3023 /** | |
| 3024 * The type representing the type 'bottom'. | |
| 3025 */ | |
| 3026 Type2 _bottomType; | |
| 3027 /** | |
| 3028 * The type representing the built-in type 'double'. | |
| 3029 */ | |
| 3030 InterfaceType _doubleType; | |
| 3031 /** | |
| 3032 * The type representing the built-in type 'dynamic'. | |
| 3033 */ | |
| 3034 Type2 _dynamicType; | |
| 3035 /** | |
| 3036 * The type representing the built-in type 'Function'. | |
| 3037 */ | |
| 3038 InterfaceType _functionType; | |
| 3039 /** | |
| 3040 * The type representing the built-in type 'int'. | |
| 3041 */ | |
| 3042 InterfaceType _intType; | |
| 3043 /** | |
| 3044 * The type representing the built-in type 'List'. | |
| 3045 */ | |
| 3046 InterfaceType _listType; | |
| 3047 /** | |
| 3048 * The type representing the built-in type 'Map'. | |
| 3049 */ | |
| 3050 InterfaceType _mapType; | |
| 3051 /** | |
| 3052 * The type representing the built-in type 'num'. | |
| 3053 */ | |
| 3054 InterfaceType _numType; | |
| 3055 /** | |
| 3056 * The type representing the built-in type 'Object'. | |
| 3057 */ | |
| 3058 InterfaceType _objectType; | |
| 3059 /** | |
| 3060 * The type representing the built-in type 'StackTrace'. | |
| 3061 */ | |
| 3062 InterfaceType _stackTraceType; | |
| 3063 /** | |
| 3064 * The type representing the built-in type 'String'. | |
| 3065 */ | |
| 3066 InterfaceType _stringType; | |
| 3067 /** | |
| 3068 * The type representing the built-in type 'Type'. | |
| 3069 */ | |
| 3070 InterfaceType _typeType; | |
| 3071 /** | |
| 3072 * Initialize a newly created type provider to provide stand-ins for the types
defined in the core | |
| 3073 * library. | |
| 3074 */ | |
| 3075 TestTypeProvider() : super() { | |
| 3076 } | |
| 3077 InterfaceType get boolType { | |
| 3078 if (_boolType == null) { | |
| 3079 _boolType = ElementFactory.classElement2("bool", []).type; | |
| 3080 } | |
| 3081 return _boolType; | |
| 3082 } | |
| 3083 Type2 get bottomType { | |
| 3084 if (_bottomType == null) { | |
| 3085 _bottomType = BottomTypeImpl.instance; | |
| 3086 } | |
| 3087 return _bottomType; | |
| 3088 } | |
| 3089 InterfaceType get doubleType { | |
| 3090 if (_doubleType == null) { | |
| 3091 initializeNumericTypes(); | |
| 3092 } | |
| 3093 return _doubleType; | |
| 3094 } | |
| 3095 Type2 get dynamicType { | |
| 3096 if (_dynamicType == null) { | |
| 3097 _dynamicType = DynamicTypeImpl.instance; | |
| 3098 } | |
| 3099 return _dynamicType; | |
| 3100 } | |
| 3101 InterfaceType get functionType { | |
| 3102 if (_functionType == null) { | |
| 3103 _functionType = ElementFactory.classElement2("Function", []).type; | |
| 3104 } | |
| 3105 return _functionType; | |
| 3106 } | |
| 3107 InterfaceType get intType { | |
| 3108 if (_intType == null) { | |
| 3109 initializeNumericTypes(); | |
| 3110 } | |
| 3111 return _intType; | |
| 3112 } | |
| 3113 InterfaceType get listType { | |
| 3114 if (_listType == null) { | |
| 3115 ClassElementImpl listElement = ElementFactory.classElement2("List", ["E"])
; | |
| 3116 _listType = listElement.type; | |
| 3117 Type2 eType = listElement.typeVariables[0].type; | |
| 3118 listElement.methods = <MethodElement> [ElementFactory.methodElement("[]",
eType, [_intType]), ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [
_intType, eType])]; | |
| 3119 } | |
| 3120 return _listType; | |
| 3121 } | |
| 3122 InterfaceType get mapType { | |
| 3123 if (_mapType == null) { | |
| 3124 _mapType = ElementFactory.classElement2("Map", ["K", "V"]).type; | |
| 3125 } | |
| 3126 return _mapType; | |
| 3127 } | |
| 3128 InterfaceType get numType { | |
| 3129 if (_numType == null) { | |
| 3130 initializeNumericTypes(); | |
| 3131 } | |
| 3132 return _numType; | |
| 3133 } | |
| 3134 InterfaceType get objectType { | |
| 3135 if (_objectType == null) { | |
| 3136 ClassElementImpl objectElement = ElementFactory.object; | |
| 3137 _objectType = objectElement.type; | |
| 3138 if (objectElement.methods.length == 0) { | |
| 3139 objectElement.methods = <MethodElement> [ElementFactory.methodElement("t
oString", stringType, []), ElementFactory.methodElement("==", _boolType, [_objec
tType])]; | |
| 3140 objectElement.accessors = <PropertyAccessorElement> [ElementFactory.gett
erElement("hashCode", false, intType)]; | |
| 3141 } | |
| 3142 } | |
| 3143 return _objectType; | |
| 3144 } | |
| 3145 InterfaceType get stackTraceType { | |
| 3146 if (_stackTraceType == null) { | |
| 3147 _stackTraceType = ElementFactory.classElement2("StackTrace", []).type; | |
| 3148 } | |
| 3149 return _stackTraceType; | |
| 3150 } | |
| 3151 InterfaceType get stringType { | |
| 3152 if (_stringType == null) { | |
| 3153 _stringType = ElementFactory.classElement2("String", []).type; | |
| 3154 ClassElementImpl stringElement = _stringType.element as ClassElementImpl; | |
| 3155 stringElement.accessors = <PropertyAccessorElement> [ElementFactory.getter
Element("length", false, intType)]; | |
| 3156 } | |
| 3157 return _stringType; | |
| 3158 } | |
| 3159 InterfaceType get typeType { | |
| 3160 if (_typeType == null) { | |
| 3161 _typeType = ElementFactory.classElement2("Type", []).type; | |
| 3162 } | |
| 3163 return _typeType; | |
| 3164 } | |
| 3165 /** | |
| 3166 * Initialize the numeric types. They are created as a group so that we can (a
) create the right | |
| 3167 * hierarchy and (b) add members to them. | |
| 3168 */ | |
| 3169 void initializeNumericTypes() { | |
| 3170 ClassElementImpl numElement = ElementFactory.classElement2("num", []); | |
| 3171 _numType = numElement.type; | |
| 3172 ClassElementImpl intElement = ElementFactory.classElement("int", _numType, [
]); | |
| 3173 _intType = intElement.type; | |
| 3174 ClassElementImpl doubleElement = ElementFactory.classElement("double", _numT
ype, []); | |
| 3175 _doubleType = doubleElement.type; | |
| 3176 boolType; | |
| 3177 stringType; | |
| 3178 numElement.methods = <MethodElement> [ElementFactory.methodElement("+", _num
Type, [_numType]), ElementFactory.methodElement("-", _numType, [_numType]), Elem
entFactory.methodElement("*", _numType, [_numType]), ElementFactory.methodElemen
t("%", _numType, [_numType]), ElementFactory.methodElement("/", _doubleType, [_n
umType]), ElementFactory.methodElement("~/", _numType, [_numType]), ElementFacto
ry.methodElement("-", _numType, []), ElementFactory.methodElement("remainder", _
numType, [_numType]), ElementFactory.methodElement("<", _boolType, [_numType]),
ElementFactory.methodElement("<=", _boolType, [_numType]), ElementFactory.method
Element(">", _boolType, [_numType]), ElementFactory.methodElement(">=", _boolTyp
e, [_numType]), ElementFactory.methodElement("isNaN", _boolType, []), ElementFac
tory.methodElement("isNegative", _boolType, []), ElementFactory.methodElement("i
sInfinite", _boolType, []), ElementFactory.methodElement("abs", _numType, []), E
lementFactory.methodElement("floor", _numType, []), ElementFactory.methodElement
("ceil", _numType, []), ElementFactory.methodElement("round", _numType, []), Ele
mentFactory.methodElement("truncate", _numType, []), ElementFactory.methodElemen
t("toInt", _intType, []), ElementFactory.methodElement("toDouble", _doubleType,
[]), ElementFactory.methodElement("toStringAsFixed", _stringType, [_intType]), E
lementFactory.methodElement("toStringAsExponential", _stringType, [_intType]), E
lementFactory.methodElement("toStringAsPrecision", _stringType, [_intType]), Ele
mentFactory.methodElement("toRadixString", _stringType, [_intType])]; | |
| 3179 intElement.methods = <MethodElement> [ElementFactory.methodElement("&", _int
Type, [_intType]), ElementFactory.methodElement("|", _intType, [_intType]), Elem
entFactory.methodElement("^", _intType, [_intType]), ElementFactory.methodElemen
t("~", _intType, []), ElementFactory.methodElement("<<", _intType, [_intType]),
ElementFactory.methodElement(">>", _intType, [_intType]), ElementFactory.methodE
lement("-", _intType, []), ElementFactory.methodElement("abs", _intType, []), El
ementFactory.methodElement("round", _intType, []), ElementFactory.methodElement(
"floor", _intType, []), ElementFactory.methodElement("ceil", _intType, []), Elem
entFactory.methodElement("truncate", _intType, []), ElementFactory.methodElement
("toString", _stringType, [])]; | |
| 3180 List<FieldElement> fields = <FieldElement> [ElementFactory.fieldElement("NAN
", true, false, true, _doubleType), ElementFactory.fieldElement("INFINITY", true
, false, true, _doubleType), ElementFactory.fieldElement("NEGATIVE_INFINITY", tr
ue, false, true, _doubleType), ElementFactory.fieldElement("MIN_POSITIVE", true,
false, true, _doubleType), ElementFactory.fieldElement("MAX_FINITE", true, fals
e, true, _doubleType)]; | |
| 3181 doubleElement.fields = fields; | |
| 3182 int fieldCount = fields.length; | |
| 3183 List<PropertyAccessorElement> accessors = new List<PropertyAccessorElement>(
fieldCount); | |
| 3184 for (int i = 0; i < fieldCount; i++) { | |
| 3185 accessors[i] = fields[i].getter; | |
| 3186 } | |
| 3187 doubleElement.accessors = accessors; | |
| 3188 doubleElement.methods = <MethodElement> [ElementFactory.methodElement("remai
nder", _doubleType, [_numType]), ElementFactory.methodElement("+", _doubleType,
[_numType]), ElementFactory.methodElement("-", _doubleType, [_numType]), Element
Factory.methodElement("*", _doubleType, [_numType]), ElementFactory.methodElemen
t("%", _doubleType, [_numType]), ElementFactory.methodElement("/", _doubleType,
[_numType]), ElementFactory.methodElement("~/", _doubleType, [_numType]), Elemen
tFactory.methodElement("-", _doubleType, []), ElementFactory.methodElement("abs"
, _doubleType, []), ElementFactory.methodElement("round", _doubleType, []), Elem
entFactory.methodElement("floor", _doubleType, []), ElementFactory.methodElement
("ceil", _doubleType, []), ElementFactory.methodElement("truncate", _doubleType,
[]), ElementFactory.methodElement("toString", _stringType, [])]; | |
| 3189 } | |
| 3190 } | |
| 3191 class LibraryImportScopeTest extends ResolverTestCase { | |
| 3192 void test_conflictingImports() { | |
| 3193 AnalysisContext context = new AnalysisContextImpl(); | |
| 3194 String typeNameA = "A"; | |
| 3195 String typeNameB = "B"; | |
| 3196 String typeNameC = "C"; | |
| 3197 ClassElement typeA = new ClassElementImpl(ASTFactory.identifier2(typeNameA))
; | |
| 3198 ClassElement typeB1 = new ClassElementImpl(ASTFactory.identifier2(typeNameB)
); | |
| 3199 ClassElement typeB2 = new ClassElementImpl(ASTFactory.identifier2(typeNameB)
); | |
| 3200 ClassElement typeC = new ClassElementImpl(ASTFactory.identifier2(typeNameC))
; | |
| 3201 LibraryElement importedLibrary1 = createTestLibrary2(context, "imported1", [
]); | |
| 3202 ((importedLibrary1.definingCompilationUnit as CompilationUnitElementImpl)).t
ypes = <ClassElement> [typeA, typeB1]; | |
| 3203 ImportElementImpl import1 = new ImportElementImpl(); | |
| 3204 import1.importedLibrary = importedLibrary1; | |
| 3205 LibraryElement importedLibrary2 = createTestLibrary2(context, "imported2", [
]); | |
| 3206 ((importedLibrary2.definingCompilationUnit as CompilationUnitElementImpl)).t
ypes = <ClassElement> [typeB2, typeC]; | |
| 3207 ImportElementImpl import2 = new ImportElementImpl(); | |
| 3208 import2.importedLibrary = importedLibrary2; | |
| 3209 LibraryElementImpl importingLibrary = createTestLibrary2(context, "importing
", []); | |
| 3210 importingLibrary.imports = <ImportElement> [import1, import2]; | |
| 3211 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3212 Scope scope = new LibraryImportScope(importingLibrary, errorListener); | |
| 3213 JUnitTestCase.assertEquals(typeA, scope.lookup3(typeNameA, importingLibrary)
); | |
| 3214 errorListener.assertNoErrors(); | |
| 3215 JUnitTestCase.assertEquals(typeC, scope.lookup3(typeNameC, importingLibrary)
); | |
| 3216 errorListener.assertNoErrors(); | |
| 3217 Element element = scope.lookup3(typeNameB, importingLibrary); | |
| 3218 errorListener.assertNoErrors(); | |
| 3219 EngineTestCase.assertInstanceOf(MultiplyDefinedElement, element); | |
| 3220 List<Element> conflictingElements2 = ((element as MultiplyDefinedElement)).c
onflictingElements; | |
| 3221 JUnitTestCase.assertEquals(typeB1, conflictingElements2[0]); | |
| 3222 JUnitTestCase.assertEquals(typeB2, conflictingElements2[1]); | |
| 3223 JUnitTestCase.assertEquals(2, conflictingElements2.length); | |
| 3224 } | |
| 3225 void test_creation_empty() { | |
| 3226 LibraryElement definingLibrary = createTestLibrary(); | |
| 3227 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3228 new LibraryImportScope(definingLibrary, errorListener); | |
| 3229 } | |
| 3230 void test_creation_nonEmpty() { | |
| 3231 AnalysisContext context = new AnalysisContextImpl(); | |
| 3232 String importedTypeName = "A"; | |
| 3233 ClassElement importedType = new ClassElementImpl(ASTFactory.identifier2(impo
rtedTypeName)); | |
| 3234 LibraryElement importedLibrary = createTestLibrary2(context, "imported", [])
; | |
| 3235 ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).ty
pes = <ClassElement> [importedType]; | |
| 3236 LibraryElementImpl definingLibrary = createTestLibrary2(context, "importing"
, []); | |
| 3237 ImportElementImpl importElement = new ImportElementImpl(); | |
| 3238 importElement.importedLibrary = importedLibrary; | |
| 3239 definingLibrary.imports = <ImportElement> [importElement]; | |
| 3240 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3241 Scope scope = new LibraryImportScope(definingLibrary, errorListener); | |
| 3242 JUnitTestCase.assertEquals(importedType, scope.lookup3(importedTypeName, def
iningLibrary)); | |
| 3243 } | |
| 3244 void test_getDefiningLibrary() { | |
| 3245 LibraryElement definingLibrary = createTestLibrary(); | |
| 3246 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3247 Scope scope = new LibraryImportScope(definingLibrary, errorListener); | |
| 3248 JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary); | |
| 3249 } | |
| 3250 void test_getErrorListener() { | |
| 3251 LibraryElement definingLibrary = createTestLibrary(); | |
| 3252 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3253 Scope scope = new LibraryImportScope(definingLibrary, errorListener); | |
| 3254 JUnitTestCase.assertEquals(errorListener, scope.errorListener); | |
| 3255 } | |
| 3256 static dartSuite() { | |
| 3257 _ut.group('LibraryImportScopeTest', () { | |
| 3258 _ut.test('test_conflictingImports', () { | |
| 3259 final __test = new LibraryImportScopeTest(); | |
| 3260 runJUnitTest(__test, __test.test_conflictingImports); | |
| 3261 }); | |
| 3262 _ut.test('test_creation_empty', () { | |
| 3263 final __test = new LibraryImportScopeTest(); | |
| 3264 runJUnitTest(__test, __test.test_creation_empty); | |
| 3265 }); | |
| 3266 _ut.test('test_creation_nonEmpty', () { | |
| 3267 final __test = new LibraryImportScopeTest(); | |
| 3268 runJUnitTest(__test, __test.test_creation_nonEmpty); | |
| 3269 }); | |
| 3270 _ut.test('test_getDefiningLibrary', () { | |
| 3271 final __test = new LibraryImportScopeTest(); | |
| 3272 runJUnitTest(__test, __test.test_getDefiningLibrary); | |
| 3273 }); | |
| 3274 _ut.test('test_getErrorListener', () { | |
| 3275 final __test = new LibraryImportScopeTest(); | |
| 3276 runJUnitTest(__test, __test.test_getErrorListener); | |
| 3277 }); | |
| 3278 }); | |
| 3279 } | |
| 3280 } | |
| 3281 /** | |
| 3282 * Instances of the class {@code ResolutionVerifier} verify that all of the node
s in an AST | |
| 3283 * structure that should have been resolved were resolved. | |
| 3284 */ | |
| 3285 class ResolutionVerifier extends RecursiveASTVisitor<Object> { | |
| 3286 /** | |
| 3287 * A set containing nodes that are known to not be resolvable and should there
fore not cause the | |
| 3288 * test to fail. | |
| 3289 */ | |
| 3290 Set<ASTNode> _knownExceptions; | |
| 3291 /** | |
| 3292 * A list containing all of the AST nodes that were not resolved. | |
| 3293 */ | |
| 3294 List<ASTNode> _unresolvedNodes = new List<ASTNode>(); | |
| 3295 /** | |
| 3296 * A list containing all of the AST nodes that were resolved to an element of
the wrong type. | |
| 3297 */ | |
| 3298 List<ASTNode> _wrongTypedNodes = new List<ASTNode>(); | |
| 3299 /** | |
| 3300 * Initialize a newly created verifier to verify that all of the nodes in the
visited AST | |
| 3301 * structures that are expected to have been resolved have an element associat
ed with them. | |
| 3302 */ | |
| 3303 ResolutionVerifier() { | |
| 3304 _jtd_constructor_306_impl(); | |
| 3305 } | |
| 3306 _jtd_constructor_306_impl() { | |
| 3307 _jtd_constructor_307_impl(null); | |
| 3308 } | |
| 3309 /** | |
| 3310 * Initialize a newly created verifier to verify that all of the identifiers i
n the visited AST | |
| 3311 * structures that are expected to have been resolved have an element associat
ed with them. Nodes | |
| 3312 * in the set of known exceptions are not expected to have been resolved, even
if they normally | |
| 3313 * would have been expected to have been resolved. | |
| 3314 * @param knownExceptions a set containing nodes that are known to not be reso
lvable and should | |
| 3315 * therefore not cause the test to fail | |
| 3316 */ | |
| 3317 ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) { | |
| 3318 _jtd_constructor_307_impl(knownExceptions2); | |
| 3319 } | |
| 3320 _jtd_constructor_307_impl(Set<ASTNode> knownExceptions2) { | |
| 3321 this._knownExceptions = knownExceptions2; | |
| 3322 } | |
| 3323 /** | |
| 3324 * Assert that all of the visited identifiers were resolved. | |
| 3325 */ | |
| 3326 void assertResolved() { | |
| 3327 if (!_unresolvedNodes.isEmpty || !_wrongTypedNodes.isEmpty) { | |
| 3328 PrintStringWriter writer = new PrintStringWriter(); | |
| 3329 if (!_unresolvedNodes.isEmpty) { | |
| 3330 writer.print("Failed to resolve "); | |
| 3331 writer.print(_unresolvedNodes.length); | |
| 3332 writer.printlnObject(" nodes:"); | |
| 3333 printNodes(writer, _unresolvedNodes); | |
| 3334 } | |
| 3335 if (!_wrongTypedNodes.isEmpty) { | |
| 3336 writer.print("Resolved "); | |
| 3337 writer.print(_wrongTypedNodes.length); | |
| 3338 writer.printlnObject(" to the wrong type of element:"); | |
| 3339 printNodes(writer, _wrongTypedNodes); | |
| 3340 } | |
| 3341 JUnitTestCase.fail(writer.toString()); | |
| 3342 } | |
| 3343 } | |
| 3344 Object visitBinaryExpression(BinaryExpression node) { | |
| 3345 node.visitChildren(this); | |
| 3346 if (!node.operator.isUserDefinableOperator()) { | |
| 3347 return null; | |
| 3348 } | |
| 3349 return checkResolved2(node, node.element, MethodElement); | |
| 3350 } | |
| 3351 Object visitCompilationUnit(CompilationUnit node) { | |
| 3352 node.visitChildren(this); | |
| 3353 return checkResolved2(node, node.element, CompilationUnitElement); | |
| 3354 } | |
| 3355 Object visitExportDirective(ExportDirective node) => checkResolved2(node, node
.element, ExportElement); | |
| 3356 Object visitFunctionDeclaration(FunctionDeclaration node) { | |
| 3357 node.visitChildren(this); | |
| 3358 if (node.element is LibraryElement) { | |
| 3359 _wrongTypedNodes.add(node); | |
| 3360 } | |
| 3361 return null; | |
| 3362 } | |
| 3363 Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) { | |
| 3364 node.visitChildren(this); | |
| 3365 return checkResolved2(node, node.element, FunctionElement); | |
| 3366 } | |
| 3367 Object visitImportDirective(ImportDirective node) { | |
| 3368 checkResolved2(node, node.element, ImportElement); | |
| 3369 SimpleIdentifier prefix10 = node.prefix; | |
| 3370 if (prefix10 == null) { | |
| 3371 return null; | |
| 3372 } | |
| 3373 return checkResolved2(prefix10, prefix10.element, PrefixElement); | |
| 3374 } | |
| 3375 Object visitIndexExpression(IndexExpression node) { | |
| 3376 node.visitChildren(this); | |
| 3377 return checkResolved2(node, node.element, MethodElement); | |
| 3378 } | |
| 3379 Object visitLibraryDirective(LibraryDirective node) => checkResolved2(node, no
de.element, LibraryElement); | |
| 3380 Object visitPartDirective(PartDirective node) => checkResolved2(node, node.ele
ment, CompilationUnitElement); | |
| 3381 Object visitPartOfDirective(PartOfDirective node) => checkResolved2(node, node
.element, LibraryElement); | |
| 3382 Object visitPostfixExpression(PostfixExpression node) { | |
| 3383 node.visitChildren(this); | |
| 3384 if (!node.operator.isUserDefinableOperator()) { | |
| 3385 return null; | |
| 3386 } | |
| 3387 return checkResolved2(node, node.element, MethodElement); | |
| 3388 } | |
| 3389 Object visitPrefixExpression(PrefixExpression node) { | |
| 3390 node.visitChildren(this); | |
| 3391 if (!node.operator.isUserDefinableOperator()) { | |
| 3392 return null; | |
| 3393 } | |
| 3394 return checkResolved2(node, node.element, MethodElement); | |
| 3395 } | |
| 3396 Object visitSimpleIdentifier(SimpleIdentifier node) { | |
| 3397 if (node.name == "void") { | |
| 3398 return null; | |
| 3399 } | |
| 3400 return checkResolved(node, node.element); | |
| 3401 } | |
| 3402 Object checkResolved(ASTNode node, Element element) => checkResolved2(node, el
ement, null); | |
| 3403 Object checkResolved2(ASTNode node, Element element, Type expectedClass) { | |
| 3404 if (element == null) { | |
| 3405 if (node.parent is CommentReference) { | |
| 3406 return null; | |
| 3407 } | |
| 3408 if (_knownExceptions == null || !_knownExceptions.contains(node)) { | |
| 3409 _unresolvedNodes.add(node); | |
| 3410 } | |
| 3411 } else if (expectedClass != null) { | |
| 3412 if (!isInstanceOf(element, expectedClass)) { | |
| 3413 _wrongTypedNodes.add(node); | |
| 3414 } | |
| 3415 } | |
| 3416 return null; | |
| 3417 } | |
| 3418 String getFileName(ASTNode node) { | |
| 3419 if (node != null) { | |
| 3420 ASTNode root2 = node.root; | |
| 3421 if (root2 is CompilationUnit) { | |
| 3422 CompilationUnit rootCU = (root2 as CompilationUnit); | |
| 3423 if (rootCU.element != null) { | |
| 3424 return rootCU.element.source.fullName; | |
| 3425 } else { | |
| 3426 return "<unknown file- CompilationUnit.getElement() returned null>"; | |
| 3427 } | |
| 3428 } else { | |
| 3429 return "<unknown file- CompilationUnit.getRoot() is not a CompilationUni
t>"; | |
| 3430 } | |
| 3431 } | |
| 3432 return "<unknown file- ASTNode is null>"; | |
| 3433 } | |
| 3434 void printNodes(PrintStringWriter writer, List<ASTNode> nodes) { | |
| 3435 for (ASTNode identifier in nodes) { | |
| 3436 writer.print(" "); | |
| 3437 writer.print(identifier.toString()); | |
| 3438 writer.print(" ("); | |
| 3439 writer.print(getFileName(identifier)); | |
| 3440 writer.print(" : "); | |
| 3441 writer.print(identifier.offset); | |
| 3442 writer.printlnObject(")"); | |
| 3443 } | |
| 3444 } | |
| 3445 } | |
| 3446 class LibraryScopeTest extends ResolverTestCase { | |
| 3447 void test_creation_empty() { | |
| 3448 LibraryElement definingLibrary = createTestLibrary(); | |
| 3449 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3450 new LibraryScope(definingLibrary, errorListener); | |
| 3451 } | |
| 3452 void test_creation_nonEmpty() { | |
| 3453 AnalysisContext context = new AnalysisContextImpl(); | |
| 3454 String importedTypeName = "A"; | |
| 3455 ClassElement importedType = new ClassElementImpl(ASTFactory.identifier2(impo
rtedTypeName)); | |
| 3456 LibraryElement importedLibrary = createTestLibrary2(context, "imported", [])
; | |
| 3457 ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).ty
pes = <ClassElement> [importedType]; | |
| 3458 LibraryElementImpl definingLibrary = createTestLibrary2(context, "importing"
, []); | |
| 3459 ImportElementImpl importElement = new ImportElementImpl(); | |
| 3460 importElement.importedLibrary = importedLibrary; | |
| 3461 definingLibrary.imports = <ImportElement> [importElement]; | |
| 3462 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3463 Scope scope = new LibraryScope(definingLibrary, errorListener); | |
| 3464 JUnitTestCase.assertEquals(importedType, scope.lookup3(importedTypeName, def
iningLibrary)); | |
| 3465 } | |
| 3466 void test_getDefiningLibrary() { | |
| 3467 LibraryElement definingLibrary = createTestLibrary(); | |
| 3468 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3469 Scope scope = new LibraryScope(definingLibrary, errorListener); | |
| 3470 JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary); | |
| 3471 } | |
| 3472 void test_getErrorListener() { | |
| 3473 LibraryElement definingLibrary = createTestLibrary(); | |
| 3474 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 3475 Scope scope = new LibraryScope(definingLibrary, errorListener); | |
| 3476 JUnitTestCase.assertEquals(errorListener, scope.errorListener); | |
| 3477 } | |
| 3478 static dartSuite() { | |
| 3479 _ut.group('LibraryScopeTest', () { | |
| 3480 _ut.test('test_creation_empty', () { | |
| 3481 final __test = new LibraryScopeTest(); | |
| 3482 runJUnitTest(__test, __test.test_creation_empty); | |
| 3483 }); | |
| 3484 _ut.test('test_creation_nonEmpty', () { | |
| 3485 final __test = new LibraryScopeTest(); | |
| 3486 runJUnitTest(__test, __test.test_creation_nonEmpty); | |
| 3487 }); | |
| 3488 _ut.test('test_getDefiningLibrary', () { | |
| 3489 final __test = new LibraryScopeTest(); | |
| 3490 runJUnitTest(__test, __test.test_getDefiningLibrary); | |
| 3491 }); | |
| 3492 _ut.test('test_getErrorListener', () { | |
| 3493 final __test = new LibraryScopeTest(); | |
| 3494 runJUnitTest(__test, __test.test_getErrorListener); | |
| 3495 }); | |
| 3496 }); | |
| 3497 } | |
| 3498 } | |
| 3499 class StaticTypeAnalyzerTest extends EngineTestCase { | |
| 3500 /** | |
| 3501 * The error listener to which errors will be reported. | |
| 3502 */ | |
| 3503 GatheringErrorListener _listener; | |
| 3504 /** | |
| 3505 * The analyzer being used to analyze the test cases. | |
| 3506 */ | |
| 3507 StaticTypeAnalyzer _analyzer; | |
| 3508 /** | |
| 3509 * The type provider used to access the types. | |
| 3510 */ | |
| 3511 TestTypeProvider _typeProvider; | |
| 3512 void fail_visitFunctionExpressionInvocation() { | |
| 3513 JUnitTestCase.fail("Not yet tested"); | |
| 3514 _listener.assertNoErrors(); | |
| 3515 } | |
| 3516 void fail_visitIndexExpression_typeParameters() { | |
| 3517 InterfaceType intType6 = _typeProvider.intType; | |
| 3518 InterfaceType listType2 = _typeProvider.listType; | |
| 3519 MethodElement methodElement = getMethod(listType2, "[]"); | |
| 3520 SimpleIdentifier identifier = ASTFactory.identifier2("list"); | |
| 3521 identifier.staticType = listType2.substitute5(<Type2> [intType6]); | |
| 3522 IndexExpression indexExpression2 = ASTFactory.indexExpression(identifier, AS
TFactory.integer(0)); | |
| 3523 indexExpression2.element = methodElement; | |
| 3524 JUnitTestCase.assertSame(intType6, analyze(indexExpression2)); | |
| 3525 _listener.assertNoErrors(); | |
| 3526 } | |
| 3527 void fail_visitMethodInvocation() { | |
| 3528 JUnitTestCase.fail("Not yet tested"); | |
| 3529 _listener.assertNoErrors(); | |
| 3530 } | |
| 3531 void fail_visitSimpleIdentifier() { | |
| 3532 JUnitTestCase.fail("Not yet tested"); | |
| 3533 _listener.assertNoErrors(); | |
| 3534 } | |
| 3535 void setUp() { | |
| 3536 _listener = new GatheringErrorListener(); | |
| 3537 _typeProvider = new TestTypeProvider(); | |
| 3538 _analyzer = createAnalyzer(); | |
| 3539 } | |
| 3540 void test_visitAdjacentStrings() { | |
| 3541 Expression node = ASTFactory.adjacentStrings([resolvedString("a"), resolvedS
tring("b")]); | |
| 3542 JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node)); | |
| 3543 _listener.assertNoErrors(); | |
| 3544 } | |
| 3545 void test_visitArgumentDefinitionTest() { | |
| 3546 Expression node = ASTFactory.argumentDefinitionTest("p"); | |
| 3547 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3548 _listener.assertNoErrors(); | |
| 3549 } | |
| 3550 void test_visitAsExpression() { | |
| 3551 ClassElement superclass = ElementFactory.classElement2("A", []); | |
| 3552 InterfaceType superclassType = superclass.type; | |
| 3553 ClassElement subclass = ElementFactory.classElement("B", superclassType, [])
; | |
| 3554 Expression node = ASTFactory.asExpression(ASTFactory.thisExpression(), ASTFa
ctory.typeName(subclass, [])); | |
| 3555 JUnitTestCase.assertSame(subclass.type, analyze2(node, superclassType)); | |
| 3556 _listener.assertNoErrors(); | |
| 3557 } | |
| 3558 void test_visitAssignmentExpression_compound() { | |
| 3559 InterfaceType numType6 = _typeProvider.numType; | |
| 3560 SimpleIdentifier identifier = resolvedVariable(_typeProvider.intType, "i"); | |
| 3561 AssignmentExpression node = ASTFactory.assignmentExpression(identifier, Toke
nType.PLUS_EQ, resolvedInteger(1)); | |
| 3562 node.element = getMethod(numType6, "+"); | |
| 3563 JUnitTestCase.assertSame(numType6, analyze(node)); | |
| 3564 _listener.assertNoErrors(); | |
| 3565 } | |
| 3566 void test_visitAssignmentExpression_simple() { | |
| 3567 InterfaceType intType7 = _typeProvider.intType; | |
| 3568 Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType7,
"i"), TokenType.EQ, resolvedInteger(0)); | |
| 3569 JUnitTestCase.assertSame(intType7, analyze(node)); | |
| 3570 _listener.assertNoErrors(); | |
| 3571 } | |
| 3572 void test_visitBinaryExpression_equals() { | |
| 3573 Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.
EQ_EQ, resolvedInteger(3)); | |
| 3574 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3575 _listener.assertNoErrors(); | |
| 3576 } | |
| 3577 void test_visitBinaryExpression_logicalAnd() { | |
| 3578 Expression node = ASTFactory.binaryExpression(ASTFactory.booleanLiteral(fals
e), TokenType.AMPERSAND_AMPERSAND, ASTFactory.booleanLiteral(true)); | |
| 3579 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3580 _listener.assertNoErrors(); | |
| 3581 } | |
| 3582 void test_visitBinaryExpression_logicalOr() { | |
| 3583 Expression node = ASTFactory.binaryExpression(ASTFactory.booleanLiteral(fals
e), TokenType.BAR_BAR, ASTFactory.booleanLiteral(true)); | |
| 3584 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3585 _listener.assertNoErrors(); | |
| 3586 } | |
| 3587 void test_visitBinaryExpression_notEquals() { | |
| 3588 Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.
BANG_EQ, resolvedInteger(3)); | |
| 3589 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3590 _listener.assertNoErrors(); | |
| 3591 } | |
| 3592 void test_visitBinaryExpression_plus() { | |
| 3593 BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(2), Toke
nType.PLUS, resolvedInteger(2)); | |
| 3594 node.element = getMethod(_typeProvider.numType, "+"); | |
| 3595 JUnitTestCase.assertSame(_typeProvider.numType, analyze(node)); | |
| 3596 _listener.assertNoErrors(); | |
| 3597 } | |
| 3598 void test_visitBooleanLiteral_false() { | |
| 3599 Expression node = ASTFactory.booleanLiteral(false); | |
| 3600 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3601 _listener.assertNoErrors(); | |
| 3602 } | |
| 3603 void test_visitBooleanLiteral_true() { | |
| 3604 Expression node = ASTFactory.booleanLiteral(true); | |
| 3605 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3606 _listener.assertNoErrors(); | |
| 3607 } | |
| 3608 void test_visitCascadeExpression() { | |
| 3609 Expression node = ASTFactory.cascadeExpression(resolvedString("a"), [ASTFact
ory.propertyAccess2(null, "length")]); | |
| 3610 JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node)); | |
| 3611 _listener.assertNoErrors(); | |
| 3612 } | |
| 3613 void test_visitConditionalExpression_differentTypes() { | |
| 3614 Expression node = ASTFactory.conditionalExpression(ASTFactory.booleanLiteral
(true), resolvedDouble(1.0), resolvedInteger(0)); | |
| 3615 JUnitTestCase.assertSame(_typeProvider.numType, analyze(node)); | |
| 3616 _listener.assertNoErrors(); | |
| 3617 } | |
| 3618 void test_visitConditionalExpression_sameTypes() { | |
| 3619 Expression node = ASTFactory.conditionalExpression(ASTFactory.booleanLiteral
(true), resolvedInteger(1), resolvedInteger(0)); | |
| 3620 JUnitTestCase.assertSame(_typeProvider.intType, analyze(node)); | |
| 3621 _listener.assertNoErrors(); | |
| 3622 } | |
| 3623 void test_visitDoubleLiteral() { | |
| 3624 Expression node = ASTFactory.doubleLiteral(4.33); | |
| 3625 JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node)); | |
| 3626 _listener.assertNoErrors(); | |
| 3627 } | |
| 3628 void test_visitFunctionExpression_named_block() { | |
| 3629 Type2 dynamicType3 = _typeProvider.dynamicType; | |
| 3630 FormalParameter p1 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormal
Parameter3("p1"), resolvedInteger(0)); | |
| 3631 setType(p1, dynamicType3); | |
| 3632 FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormal
Parameter3("p2"), resolvedInteger(0)); | |
| 3633 setType(p2, dynamicType3); | |
| 3634 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.blockFunctionBody([])); | |
| 3635 analyze3(p1); | |
| 3636 analyze3(p2); | |
| 3637 Type2 resultType = analyze(node); | |
| 3638 Map<String, Type2> expectedNamedTypes = new Map<String, Type2>(); | |
| 3639 expectedNamedTypes["p1"] = dynamicType3; | |
| 3640 expectedNamedTypes["p2"] = dynamicType3; | |
| 3641 assertFunctionType(dynamicType3, null, null, expectedNamedTypes, resultType)
; | |
| 3642 _listener.assertNoErrors(); | |
| 3643 } | |
| 3644 void test_visitFunctionExpression_named_expression() { | |
| 3645 Type2 dynamicType4 = _typeProvider.dynamicType; | |
| 3646 FormalParameter p = ASTFactory.namedFormalParameter(ASTFactory.simpleFormalP
arameter3("p"), resolvedInteger(0)); | |
| 3647 setType(p, dynamicType4); | |
| 3648 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0))); | |
| 3649 analyze3(p); | |
| 3650 Type2 resultType = analyze(node); | |
| 3651 Map<String, Type2> expectedNamedTypes = new Map<String, Type2>(); | |
| 3652 expectedNamedTypes["p"] = dynamicType4; | |
| 3653 assertFunctionType(_typeProvider.intType, null, null, expectedNamedTypes, re
sultType); | |
| 3654 _listener.assertNoErrors(); | |
| 3655 } | |
| 3656 void test_visitFunctionExpression_normal_block() { | |
| 3657 Type2 dynamicType5 = _typeProvider.dynamicType; | |
| 3658 FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1"); | |
| 3659 setType(p1, dynamicType5); | |
| 3660 FormalParameter p2 = ASTFactory.simpleFormalParameter3("p2"); | |
| 3661 setType(p2, dynamicType5); | |
| 3662 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.blockFunctionBody([])); | |
| 3663 analyze3(p1); | |
| 3664 analyze3(p2); | |
| 3665 Type2 resultType = analyze(node); | |
| 3666 assertFunctionType(dynamicType5, <Type2> [dynamicType5, dynamicType5], null,
null, resultType); | |
| 3667 _listener.assertNoErrors(); | |
| 3668 } | |
| 3669 void test_visitFunctionExpression_normal_expression() { | |
| 3670 Type2 dynamicType6 = _typeProvider.dynamicType; | |
| 3671 FormalParameter p = ASTFactory.simpleFormalParameter3("p"); | |
| 3672 setType(p, dynamicType6); | |
| 3673 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0))); | |
| 3674 analyze3(p); | |
| 3675 Type2 resultType = analyze(node); | |
| 3676 assertFunctionType(_typeProvider.intType, <Type2> [dynamicType6], null, null
, resultType); | |
| 3677 _listener.assertNoErrors(); | |
| 3678 } | |
| 3679 void test_visitFunctionExpression_normalAndNamed_block() { | |
| 3680 Type2 dynamicType7 = _typeProvider.dynamicType; | |
| 3681 FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1"); | |
| 3682 setType(p1, dynamicType7); | |
| 3683 FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormal
Parameter3("p2"), resolvedInteger(0)); | |
| 3684 setType(p2, dynamicType7); | |
| 3685 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.blockFunctionBody([])); | |
| 3686 analyze3(p2); | |
| 3687 Type2 resultType = analyze(node); | |
| 3688 Map<String, Type2> expectedNamedTypes = new Map<String, Type2>(); | |
| 3689 expectedNamedTypes["p2"] = dynamicType7; | |
| 3690 assertFunctionType(dynamicType7, <Type2> [dynamicType7], null, expectedNamed
Types, resultType); | |
| 3691 _listener.assertNoErrors(); | |
| 3692 } | |
| 3693 void test_visitFunctionExpression_normalAndNamed_expression() { | |
| 3694 Type2 dynamicType8 = _typeProvider.dynamicType; | |
| 3695 FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1"); | |
| 3696 setType(p1, dynamicType8); | |
| 3697 FormalParameter p2 = ASTFactory.namedFormalParameter(ASTFactory.simpleFormal
Parameter3("p2"), resolvedInteger(0)); | |
| 3698 setType(p2, dynamicType8); | |
| 3699 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0))); | |
| 3700 analyze3(p2); | |
| 3701 Type2 resultType = analyze(node); | |
| 3702 Map<String, Type2> expectedNamedTypes = new Map<String, Type2>(); | |
| 3703 expectedNamedTypes["p2"] = dynamicType8; | |
| 3704 assertFunctionType(_typeProvider.intType, <Type2> [dynamicType8], null, expe
ctedNamedTypes, resultType); | |
| 3705 _listener.assertNoErrors(); | |
| 3706 } | |
| 3707 void test_visitFunctionExpression_normalAndPositional_block() { | |
| 3708 Type2 dynamicType9 = _typeProvider.dynamicType; | |
| 3709 FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1"); | |
| 3710 setType(p1, dynamicType9); | |
| 3711 FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleF
ormalParameter3("p2"), resolvedInteger(0)); | |
| 3712 setType(p2, dynamicType9); | |
| 3713 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.blockFunctionBody([])); | |
| 3714 analyze3(p1); | |
| 3715 analyze3(p2); | |
| 3716 Type2 resultType = analyze(node); | |
| 3717 assertFunctionType(dynamicType9, <Type2> [dynamicType9], <Type2> [dynamicTyp
e9], null, resultType); | |
| 3718 _listener.assertNoErrors(); | |
| 3719 } | |
| 3720 void test_visitFunctionExpression_normalAndPositional_expression() { | |
| 3721 Type2 dynamicType10 = _typeProvider.dynamicType; | |
| 3722 FormalParameter p1 = ASTFactory.simpleFormalParameter3("p1"); | |
| 3723 setType(p1, dynamicType10); | |
| 3724 FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleF
ormalParameter3("p2"), resolvedInteger(0)); | |
| 3725 setType(p2, dynamicType10); | |
| 3726 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.expressionFunctionBody(resolvedInteger(0))); | |
| 3727 analyze3(p1); | |
| 3728 analyze3(p2); | |
| 3729 Type2 resultType = analyze(node); | |
| 3730 assertFunctionType(_typeProvider.intType, <Type2> [dynamicType10], <Type2> [
dynamicType10], null, resultType); | |
| 3731 _listener.assertNoErrors(); | |
| 3732 } | |
| 3733 void test_visitFunctionExpression_positional_block() { | |
| 3734 Type2 dynamicType11 = _typeProvider.dynamicType; | |
| 3735 FormalParameter p1 = ASTFactory.positionalFormalParameter(ASTFactory.simpleF
ormalParameter3("p1"), resolvedInteger(0)); | |
| 3736 setType(p1, dynamicType11); | |
| 3737 FormalParameter p2 = ASTFactory.positionalFormalParameter(ASTFactory.simpleF
ormalParameter3("p2"), resolvedInteger(0)); | |
| 3738 setType(p2, dynamicType11); | |
| 3739 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p1, p2]), ASTFactory.blockFunctionBody([])); | |
| 3740 analyze3(p1); | |
| 3741 analyze3(p2); | |
| 3742 Type2 resultType = analyze(node); | |
| 3743 assertFunctionType(dynamicType11, null, <Type2> [dynamicType11, dynamicType1
1], null, resultType); | |
| 3744 _listener.assertNoErrors(); | |
| 3745 } | |
| 3746 void test_visitFunctionExpression_positional_expression() { | |
| 3747 Type2 dynamicType12 = _typeProvider.dynamicType; | |
| 3748 FormalParameter p = ASTFactory.positionalFormalParameter(ASTFactory.simpleFo
rmalParameter3("p"), resolvedInteger(0)); | |
| 3749 setType(p, dynamicType12); | |
| 3750 FunctionExpression node = resolvedFunctionExpression(ASTFactory.formalParame
terList([p]), ASTFactory.expressionFunctionBody(resolvedInteger(0))); | |
| 3751 analyze3(p); | |
| 3752 Type2 resultType = analyze(node); | |
| 3753 assertFunctionType(_typeProvider.intType, null, <Type2> [dynamicType12], nul
l, resultType); | |
| 3754 _listener.assertNoErrors(); | |
| 3755 } | |
| 3756 void test_visitIndexExpression_getter() { | |
| 3757 InterfaceType listType3 = _typeProvider.listType; | |
| 3758 SimpleIdentifier identifier = resolvedVariable(listType3, "a"); | |
| 3759 IndexExpression node = ASTFactory.indexExpression(identifier, resolvedIntege
r(2)); | |
| 3760 node.element = listType3.element.methods[0]; | |
| 3761 JUnitTestCase.assertSame(listType3.typeArguments[0], analyze(node)); | |
| 3762 _listener.assertNoErrors(); | |
| 3763 } | |
| 3764 void test_visitIndexExpression_setter() { | |
| 3765 InterfaceType listType4 = _typeProvider.listType; | |
| 3766 SimpleIdentifier identifier = resolvedVariable(listType4, "a"); | |
| 3767 IndexExpression node = ASTFactory.indexExpression(identifier, resolvedIntege
r(2)); | |
| 3768 node.element = listType4.element.methods[1]; | |
| 3769 ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0)); | |
| 3770 JUnitTestCase.assertSame(listType4.typeArguments[0], analyze(node)); | |
| 3771 _listener.assertNoErrors(); | |
| 3772 } | |
| 3773 void test_visitInstanceCreationExpression_named() { | |
| 3774 ClassElement classElement = ElementFactory.classElement2("C", []); | |
| 3775 String constructorName = "m"; | |
| 3776 ConstructorElementImpl constructor = ElementFactory.constructorElement(const
ructorName); | |
| 3777 FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor); | |
| 3778 constructorType.returnType = classElement.type; | |
| 3779 constructor.type = constructorType; | |
| 3780 InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(nul
l, ASTFactory.typeName(classElement, []), [ASTFactory.identifier2(constructorNam
e)]); | |
| 3781 node.element = constructor; | |
| 3782 JUnitTestCase.assertSame(classElement.type, analyze(node)); | |
| 3783 _listener.assertNoErrors(); | |
| 3784 } | |
| 3785 void test_visitInstanceCreationExpression_typeParameters() { | |
| 3786 ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]); | |
| 3787 ClassElementImpl elementI = ElementFactory.classElement2("I", []); | |
| 3788 ConstructorElementImpl constructor = ElementFactory.constructorElement(null)
; | |
| 3789 elementC.constructors = <ConstructorElement> [constructor]; | |
| 3790 FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor); | |
| 3791 constructorType.returnType = elementC.type; | |
| 3792 constructor.type = constructorType; | |
| 3793 TypeName typeName4 = ASTFactory.typeName(elementC, [ASTFactory.typeName(elem
entI, [])]); | |
| 3794 typeName4.type = elementC.type.substitute5(<Type2> [elementI.type]); | |
| 3795 InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(nul
l, typeName4, []); | |
| 3796 node.element = constructor; | |
| 3797 InterfaceType interfaceType = analyze(node) as InterfaceType; | |
| 3798 List<Type2> typeArgs = interfaceType.typeArguments; | |
| 3799 JUnitTestCase.assertEquals(1, typeArgs.length); | |
| 3800 JUnitTestCase.assertEquals(elementI.type, typeArgs[0]); | |
| 3801 _listener.assertNoErrors(); | |
| 3802 } | |
| 3803 void test_visitInstanceCreationExpression_unnamed() { | |
| 3804 ClassElement classElement = ElementFactory.classElement2("C", []); | |
| 3805 ConstructorElementImpl constructor = ElementFactory.constructorElement(null)
; | |
| 3806 FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor); | |
| 3807 constructorType.returnType = classElement.type; | |
| 3808 constructor.type = constructorType; | |
| 3809 InstanceCreationExpression node = ASTFactory.instanceCreationExpression2(nul
l, ASTFactory.typeName(classElement, []), []); | |
| 3810 node.element = constructor; | |
| 3811 JUnitTestCase.assertSame(classElement.type, analyze(node)); | |
| 3812 _listener.assertNoErrors(); | |
| 3813 } | |
| 3814 void test_visitIntegerLiteral() { | |
| 3815 Expression node = resolvedInteger(42); | |
| 3816 JUnitTestCase.assertSame(_typeProvider.intType, analyze(node)); | |
| 3817 _listener.assertNoErrors(); | |
| 3818 } | |
| 3819 void test_visitIsExpression_negated() { | |
| 3820 Expression node = ASTFactory.isExpression(resolvedString("a"), true, ASTFact
ory.typeName3("String", [])); | |
| 3821 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3822 _listener.assertNoErrors(); | |
| 3823 } | |
| 3824 void test_visitIsExpression_notNegated() { | |
| 3825 Expression node = ASTFactory.isExpression(resolvedString("a"), false, ASTFac
tory.typeName3("String", [])); | |
| 3826 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3827 _listener.assertNoErrors(); | |
| 3828 } | |
| 3829 void test_visitListLiteral_empty() { | |
| 3830 Expression node = ASTFactory.listLiteral([]); | |
| 3831 Type2 resultType = analyze(node); | |
| 3832 assertType2(_typeProvider.listType.substitute5(<Type2> [_typeProvider.dynami
cType]), resultType); | |
| 3833 _listener.assertNoErrors(); | |
| 3834 } | |
| 3835 void test_visitListLiteral_nonEmpty() { | |
| 3836 Expression node = ASTFactory.listLiteral([resolvedInteger(0)]); | |
| 3837 Type2 resultType = analyze(node); | |
| 3838 assertType2(_typeProvider.listType.substitute5(<Type2> [_typeProvider.dynami
cType]), resultType); | |
| 3839 _listener.assertNoErrors(); | |
| 3840 } | |
| 3841 void test_visitMapLiteral_empty() { | |
| 3842 Expression node = ASTFactory.mapLiteral2([]); | |
| 3843 Type2 resultType = analyze(node); | |
| 3844 assertType2(_typeProvider.mapType.substitute5(<Type2> [_typeProvider.stringT
ype, _typeProvider.dynamicType]), resultType); | |
| 3845 _listener.assertNoErrors(); | |
| 3846 } | |
| 3847 void test_visitMapLiteral_nonEmpty() { | |
| 3848 Expression node = ASTFactory.mapLiteral2([ASTFactory.mapLiteralEntry("k", re
solvedInteger(0))]); | |
| 3849 Type2 resultType = analyze(node); | |
| 3850 assertType2(_typeProvider.mapType.substitute5(<Type2> [_typeProvider.stringT
ype, _typeProvider.dynamicType]), resultType); | |
| 3851 _listener.assertNoErrors(); | |
| 3852 } | |
| 3853 void test_visitNamedExpression() { | |
| 3854 Expression node = ASTFactory.namedExpression("n", resolvedString("a")); | |
| 3855 JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node)); | |
| 3856 _listener.assertNoErrors(); | |
| 3857 } | |
| 3858 void test_visitNullLiteral() { | |
| 3859 Expression node = ASTFactory.nullLiteral(); | |
| 3860 JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node)); | |
| 3861 _listener.assertNoErrors(); | |
| 3862 } | |
| 3863 void test_visitParenthesizedExpression() { | |
| 3864 Expression node = ASTFactory.parenthesizedExpression(resolvedInteger(0)); | |
| 3865 JUnitTestCase.assertSame(_typeProvider.intType, analyze(node)); | |
| 3866 _listener.assertNoErrors(); | |
| 3867 } | |
| 3868 void test_visitPostfixExpression_minusMinus() { | |
| 3869 PostfixExpression node = ASTFactory.postfixExpression(resolvedInteger(0), To
kenType.MINUS_MINUS); | |
| 3870 JUnitTestCase.assertSame(_typeProvider.intType, analyze(node)); | |
| 3871 _listener.assertNoErrors(); | |
| 3872 } | |
| 3873 void test_visitPostfixExpression_plusPlus() { | |
| 3874 PostfixExpression node = ASTFactory.postfixExpression(resolvedInteger(0), To
kenType.PLUS_PLUS); | |
| 3875 JUnitTestCase.assertSame(_typeProvider.intType, analyze(node)); | |
| 3876 _listener.assertNoErrors(); | |
| 3877 } | |
| 3878 void test_visitPrefixedIdentifier_getter() { | |
| 3879 Type2 boolType2 = _typeProvider.boolType; | |
| 3880 PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false
, boolType2); | |
| 3881 PrefixedIdentifier node = ASTFactory.identifier4("a", "b"); | |
| 3882 node.identifier.element = getter; | |
| 3883 JUnitTestCase.assertSame(boolType2, analyze(node)); | |
| 3884 _listener.assertNoErrors(); | |
| 3885 } | |
| 3886 void test_visitPrefixedIdentifier_setter() { | |
| 3887 Type2 boolType3 = _typeProvider.boolType; | |
| 3888 FieldElementImpl field = ElementFactory.fieldElement("b", false, false, fals
e, boolType3); | |
| 3889 PropertyAccessorElement setter5 = field.setter; | |
| 3890 PrefixedIdentifier node = ASTFactory.identifier4("a", "b"); | |
| 3891 node.identifier.element = setter5; | |
| 3892 JUnitTestCase.assertSame(boolType3, analyze(node)); | |
| 3893 _listener.assertNoErrors(); | |
| 3894 } | |
| 3895 void test_visitPrefixedIdentifier_variable() { | |
| 3896 VariableElementImpl variable = ElementFactory.localVariableElement2("b"); | |
| 3897 variable.type = _typeProvider.boolType; | |
| 3898 PrefixedIdentifier node = ASTFactory.identifier4("a", "b"); | |
| 3899 node.identifier.element = variable; | |
| 3900 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3901 _listener.assertNoErrors(); | |
| 3902 } | |
| 3903 void test_visitPrefixExpression_bang() { | |
| 3904 PrefixExpression node = ASTFactory.prefixExpression(TokenType.BANG, resolved
Integer(0)); | |
| 3905 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3906 _listener.assertNoErrors(); | |
| 3907 } | |
| 3908 void test_visitPrefixExpression_minus() { | |
| 3909 PrefixExpression node = ASTFactory.prefixExpression(TokenType.MINUS, resolve
dInteger(0)); | |
| 3910 node.element = getMethod(_typeProvider.numType, "-"); | |
| 3911 JUnitTestCase.assertSame(_typeProvider.numType, analyze(node)); | |
| 3912 _listener.assertNoErrors(); | |
| 3913 } | |
| 3914 void test_visitPrefixExpression_minusMinus() { | |
| 3915 PrefixExpression node = ASTFactory.prefixExpression(TokenType.MINUS_MINUS, r
esolvedInteger(0)); | |
| 3916 node.element = getMethod(_typeProvider.numType, "-"); | |
| 3917 JUnitTestCase.assertSame(_typeProvider.numType, analyze(node)); | |
| 3918 _listener.assertNoErrors(); | |
| 3919 } | |
| 3920 void test_visitPrefixExpression_not() { | |
| 3921 Expression node = ASTFactory.prefixExpression(TokenType.BANG, ASTFactory.boo
leanLiteral(true)); | |
| 3922 JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node)); | |
| 3923 _listener.assertNoErrors(); | |
| 3924 } | |
| 3925 void test_visitPrefixExpression_plusPlus() { | |
| 3926 PrefixExpression node = ASTFactory.prefixExpression(TokenType.PLUS_PLUS, res
olvedInteger(0)); | |
| 3927 node.element = getMethod(_typeProvider.numType, "+"); | |
| 3928 JUnitTestCase.assertSame(_typeProvider.numType, analyze(node)); | |
| 3929 _listener.assertNoErrors(); | |
| 3930 } | |
| 3931 void test_visitPrefixExpression_tilde() { | |
| 3932 PrefixExpression node = ASTFactory.prefixExpression(TokenType.TILDE, resolve
dInteger(0)); | |
| 3933 node.element = getMethod(_typeProvider.intType, "~"); | |
| 3934 JUnitTestCase.assertSame(_typeProvider.intType, analyze(node)); | |
| 3935 _listener.assertNoErrors(); | |
| 3936 } | |
| 3937 void test_visitPropertyAccess_getter() { | |
| 3938 Type2 boolType4 = _typeProvider.boolType; | |
| 3939 PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false
, boolType4); | |
| 3940 PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier2("a")
, "b"); | |
| 3941 node.propertyName.element = getter; | |
| 3942 JUnitTestCase.assertSame(boolType4, analyze(node)); | |
| 3943 _listener.assertNoErrors(); | |
| 3944 } | |
| 3945 void test_visitPropertyAccess_setter() { | |
| 3946 Type2 boolType5 = _typeProvider.boolType; | |
| 3947 FieldElementImpl field = ElementFactory.fieldElement("b", false, false, fals
e, boolType5); | |
| 3948 PropertyAccessorElement setter6 = field.setter; | |
| 3949 PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier2("a")
, "b"); | |
| 3950 node.propertyName.element = setter6; | |
| 3951 JUnitTestCase.assertSame(boolType5, analyze(node)); | |
| 3952 _listener.assertNoErrors(); | |
| 3953 } | |
| 3954 void test_visitSimpleStringLiteral() { | |
| 3955 Expression node = resolvedString("a"); | |
| 3956 JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node)); | |
| 3957 _listener.assertNoErrors(); | |
| 3958 } | |
| 3959 void test_visitStringInterpolation() { | |
| 3960 Expression node = ASTFactory.string([ASTFactory.interpolationString("a", "a"
), ASTFactory.interpolationExpression(resolvedString("b")), ASTFactory.interpola
tionString("c", "c")]); | |
| 3961 JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node)); | |
| 3962 _listener.assertNoErrors(); | |
| 3963 } | |
| 3964 void test_visitSuperExpression() { | |
| 3965 InterfaceType superType = ElementFactory.classElement2("A", []).type; | |
| 3966 InterfaceType thisType = ElementFactory.classElement("B", superType, []).typ
e; | |
| 3967 Expression node = ASTFactory.superExpression(); | |
| 3968 JUnitTestCase.assertSame(superType, analyze2(node, thisType)); | |
| 3969 _listener.assertNoErrors(); | |
| 3970 } | |
| 3971 void test_visitThisExpression() { | |
| 3972 InterfaceType thisType = ElementFactory.classElement("B", ElementFactory.cla
ssElement2("A", []).type, []).type; | |
| 3973 Expression node = ASTFactory.thisExpression(); | |
| 3974 JUnitTestCase.assertSame(thisType, analyze2(node, thisType)); | |
| 3975 _listener.assertNoErrors(); | |
| 3976 } | |
| 3977 void test_visitThrowExpression_withoutValue() { | |
| 3978 Expression node = ASTFactory.throwExpression(); | |
| 3979 JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node)); | |
| 3980 _listener.assertNoErrors(); | |
| 3981 } | |
| 3982 void test_visitThrowExpression_withValue() { | |
| 3983 Expression node = ASTFactory.throwExpression2(resolvedInteger(0)); | |
| 3984 JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node)); | |
| 3985 _listener.assertNoErrors(); | |
| 3986 } | |
| 3987 /** | |
| 3988 * Return the type associated with the given expression after the static type
analyzer has | |
| 3989 * computed a type for it. | |
| 3990 * @param node the expression with which the type is associated | |
| 3991 * @return the type associated with the expression | |
| 3992 */ | |
| 3993 Type2 analyze(Expression node) => analyze2(node, null); | |
| 3994 /** | |
| 3995 * Return the type associated with the given expression after the static type
analyzer has | |
| 3996 * computed a type for it. | |
| 3997 * @param node the expression with which the type is associated | |
| 3998 * @param thisType the type of 'this' | |
| 3999 * @return the type associated with the expression | |
| 4000 */ | |
| 4001 Type2 analyze2(Expression node, InterfaceType thisType) { | |
| 4002 try { | |
| 4003 _analyzer.thisType_J2DAccessor = thisType; | |
| 4004 } on JavaException catch (exception) { | |
| 4005 throw new IllegalArgumentException("Could not set type of 'this'", excepti
on); | |
| 4006 } | |
| 4007 node.accept(_analyzer); | |
| 4008 return node.staticType; | |
| 4009 } | |
| 4010 /** | |
| 4011 * Return the type associated with the given parameter after the static type a
nalyzer has computed | |
| 4012 * a type for it. | |
| 4013 * @param node the parameter with which the type is associated | |
| 4014 * @return the type associated with the parameter | |
| 4015 */ | |
| 4016 Type2 analyze3(FormalParameter node) { | |
| 4017 node.accept(_analyzer); | |
| 4018 return ((node.identifier.element as ParameterElement)).type; | |
| 4019 } | |
| 4020 /** | |
| 4021 * Assert that the actual type is a function type with the expected characteri
stics. | |
| 4022 * @param expectedReturnType the expected return type of the function | |
| 4023 * @param expectedNormalTypes the expected types of the normal parameters | |
| 4024 * @param expectedOptionalTypes the expected types of the optional parameters | |
| 4025 * @param expectedNamedTypes the expected types of the named parameters | |
| 4026 * @param actualType the type being tested | |
| 4027 */ | |
| 4028 void assertFunctionType(Type2 expectedReturnType, List<Type2> expectedNormalTy
pes, List<Type2> expectedOptionalTypes, Map<String, Type2> expectedNamedTypes, T
ype2 actualType) { | |
| 4029 EngineTestCase.assertInstanceOf(FunctionType, actualType); | |
| 4030 FunctionType functionType = actualType as FunctionType; | |
| 4031 List<Type2> normalTypes = functionType.normalParameterTypes; | |
| 4032 if (expectedNormalTypes == null) { | |
| 4033 EngineTestCase.assertLength(0, normalTypes); | |
| 4034 } else { | |
| 4035 int expectedCount = expectedNormalTypes.length; | |
| 4036 EngineTestCase.assertLength(expectedCount, normalTypes); | |
| 4037 for (int i = 0; i < expectedCount; i++) { | |
| 4038 JUnitTestCase.assertSame(expectedNormalTypes[i], normalTypes[i]); | |
| 4039 } | |
| 4040 } | |
| 4041 List<Type2> optionalTypes = functionType.optionalParameterTypes; | |
| 4042 if (expectedOptionalTypes == null) { | |
| 4043 EngineTestCase.assertLength(0, optionalTypes); | |
| 4044 } else { | |
| 4045 int expectedCount = expectedOptionalTypes.length; | |
| 4046 EngineTestCase.assertLength(expectedCount, optionalTypes); | |
| 4047 for (int i = 0; i < expectedCount; i++) { | |
| 4048 JUnitTestCase.assertSame(expectedOptionalTypes[i], optionalTypes[i]); | |
| 4049 } | |
| 4050 } | |
| 4051 Map<String, Type2> namedTypes = functionType.namedParameterTypes; | |
| 4052 if (expectedNamedTypes == null) { | |
| 4053 EngineTestCase.assertSize2(0, namedTypes); | |
| 4054 } else { | |
| 4055 EngineTestCase.assertSize2(expectedNamedTypes.length, namedTypes); | |
| 4056 for (MapEntry<String, Type2> entry in getMapEntrySet(expectedNamedTypes))
{ | |
| 4057 JUnitTestCase.assertSame(entry.getValue(), namedTypes[entry.getKey()]); | |
| 4058 } | |
| 4059 } | |
| 4060 JUnitTestCase.assertSame(expectedReturnType, functionType.returnType); | |
| 4061 } | |
| 4062 void assertType(InterfaceTypeImpl expectedType, InterfaceTypeImpl actualType)
{ | |
| 4063 JUnitTestCase.assertEquals(expectedType.name, actualType.name); | |
| 4064 JUnitTestCase.assertEquals(expectedType.element, actualType.element); | |
| 4065 List<Type2> expectedArguments = expectedType.typeArguments; | |
| 4066 int length9 = expectedArguments.length; | |
| 4067 List<Type2> actualArguments = actualType.typeArguments; | |
| 4068 EngineTestCase.assertLength(length9, actualArguments); | |
| 4069 for (int i = 0; i < length9; i++) { | |
| 4070 assertType2(expectedArguments[i], actualArguments[i]); | |
| 4071 } | |
| 4072 } | |
| 4073 void assertType2(Type2 expectedType, Type2 actualType) { | |
| 4074 if (expectedType is InterfaceTypeImpl) { | |
| 4075 EngineTestCase.assertInstanceOf(InterfaceTypeImpl, actualType); | |
| 4076 assertType((expectedType as InterfaceTypeImpl), (actualType as InterfaceTy
peImpl)); | |
| 4077 } | |
| 4078 } | |
| 4079 /** | |
| 4080 * Create the analyzer used by the tests. | |
| 4081 * @return the analyzer to be used by the tests | |
| 4082 */ | |
| 4083 StaticTypeAnalyzer createAnalyzer() { | |
| 4084 AnalysisContextImpl context = new AnalysisContextImpl(); | |
| 4085 context.sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.
defaultSdk)]); | |
| 4086 CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElem
entImpl("lib.dart"); | |
| 4087 LibraryElementImpl definingLibrary = new LibraryElementImpl(context, null); | |
| 4088 definingLibrary.definingCompilationUnit = definingCompilationUnit; | |
| 4089 Library library = new Library(context, _listener, null); | |
| 4090 library.libraryElement = definingLibrary; | |
| 4091 ResolverVisitor visitor = new ResolverVisitor(library, null, _typeProvider); | |
| 4092 try { | |
| 4093 return visitor.typeAnalyzer_J2DAccessor as StaticTypeAnalyzer; | |
| 4094 } on JavaException catch (exception) { | |
| 4095 throw new IllegalArgumentException("Could not create analyzer", exception)
; | |
| 4096 } | |
| 4097 } | |
| 4098 /** | |
| 4099 * Return an integer literal that has been resolved to the correct type. | |
| 4100 * @param value the value of the literal | |
| 4101 * @return an integer literal that has been resolved to the correct type | |
| 4102 */ | |
| 4103 DoubleLiteral resolvedDouble(double value) { | |
| 4104 DoubleLiteral literal = ASTFactory.doubleLiteral(value); | |
| 4105 literal.staticType = _typeProvider.doubleType; | |
| 4106 return literal; | |
| 4107 } | |
| 4108 /** | |
| 4109 * Create a function expression that has an element associated with it, where
the element has an | |
| 4110 * incomplete type associated with it (just like the one{@link ElementBuilder#
visitFunctionExpression(FunctionExpression)} would have built if we had | |
| 4111 * run it). | |
| 4112 * @param parameters the parameters to the function | |
| 4113 * @param body the body of the function | |
| 4114 * @return a resolved function expression | |
| 4115 */ | |
| 4116 FunctionExpression resolvedFunctionExpression(FormalParameterList parameters15
, FunctionBody body) { | |
| 4117 for (FormalParameter parameter in parameters15.parameters) { | |
| 4118 ParameterElementImpl element = new ParameterElementImpl(parameter.identifi
er); | |
| 4119 element.parameterKind = parameter.kind; | |
| 4120 element.type = _typeProvider.dynamicType; | |
| 4121 parameter.identifier.element = element; | |
| 4122 } | |
| 4123 FunctionExpression node = ASTFactory.functionExpression2(parameters15, body)
; | |
| 4124 FunctionElementImpl element = new FunctionElementImpl.con1(null); | |
| 4125 element.type = new FunctionTypeImpl.con1(element); | |
| 4126 node.element = element; | |
| 4127 return node; | |
| 4128 } | |
| 4129 /** | |
| 4130 * Return an integer literal that has been resolved to the correct type. | |
| 4131 * @param value the value of the literal | |
| 4132 * @return an integer literal that has been resolved to the correct type | |
| 4133 */ | |
| 4134 IntegerLiteral resolvedInteger(int value) { | |
| 4135 IntegerLiteral literal = ASTFactory.integer(value); | |
| 4136 literal.staticType = _typeProvider.intType; | |
| 4137 return literal; | |
| 4138 } | |
| 4139 /** | |
| 4140 * Return a string literal that has been resolved to the correct type. | |
| 4141 * @param value the value of the literal | |
| 4142 * @return a string literal that has been resolved to the correct type | |
| 4143 */ | |
| 4144 SimpleStringLiteral resolvedString(String value) { | |
| 4145 SimpleStringLiteral string = ASTFactory.string2(value); | |
| 4146 string.staticType = _typeProvider.stringType; | |
| 4147 return string; | |
| 4148 } | |
| 4149 /** | |
| 4150 * Return a simple identifier that has been resolved to a variable element wit
h the given type. | |
| 4151 * @param type the type of the variable being represented | |
| 4152 * @param variableName the name of the variable | |
| 4153 * @return a simple identifier that has been resolved to a variable element wi
th the given type | |
| 4154 */ | |
| 4155 SimpleIdentifier resolvedVariable(InterfaceType type36, String variableName) { | |
| 4156 SimpleIdentifier identifier = ASTFactory.identifier2(variableName); | |
| 4157 VariableElementImpl element = ElementFactory.localVariableElement(identifier
); | |
| 4158 element.type = type36; | |
| 4159 identifier.element = element; | |
| 4160 identifier.staticType = type36; | |
| 4161 return identifier; | |
| 4162 } | |
| 4163 /** | |
| 4164 * Set the type of the given parameter to the given type. | |
| 4165 * @param parameter the parameter whose type is to be set | |
| 4166 * @param type the new type of the given parameter | |
| 4167 */ | |
| 4168 void setType(FormalParameter parameter, Type2 type37) { | |
| 4169 SimpleIdentifier identifier17 = parameter.identifier; | |
| 4170 Element element48 = identifier17.element; | |
| 4171 if (element48 is! ParameterElement) { | |
| 4172 element48 = new ParameterElementImpl(identifier17); | |
| 4173 identifier17.element = element48; | |
| 4174 } | |
| 4175 ((element48 as ParameterElementImpl)).type = type37; | |
| 4176 } | |
| 4177 static dartSuite() { | |
| 4178 _ut.group('StaticTypeAnalyzerTest', () { | |
| 4179 _ut.test('test_visitAdjacentStrings', () { | |
| 4180 final __test = new StaticTypeAnalyzerTest(); | |
| 4181 runJUnitTest(__test, __test.test_visitAdjacentStrings); | |
| 4182 }); | |
| 4183 _ut.test('test_visitArgumentDefinitionTest', () { | |
| 4184 final __test = new StaticTypeAnalyzerTest(); | |
| 4185 runJUnitTest(__test, __test.test_visitArgumentDefinitionTest); | |
| 4186 }); | |
| 4187 _ut.test('test_visitAsExpression', () { | |
| 4188 final __test = new StaticTypeAnalyzerTest(); | |
| 4189 runJUnitTest(__test, __test.test_visitAsExpression); | |
| 4190 }); | |
| 4191 _ut.test('test_visitAssignmentExpression_compound', () { | |
| 4192 final __test = new StaticTypeAnalyzerTest(); | |
| 4193 runJUnitTest(__test, __test.test_visitAssignmentExpression_compound); | |
| 4194 }); | |
| 4195 _ut.test('test_visitAssignmentExpression_simple', () { | |
| 4196 final __test = new StaticTypeAnalyzerTest(); | |
| 4197 runJUnitTest(__test, __test.test_visitAssignmentExpression_simple); | |
| 4198 }); | |
| 4199 _ut.test('test_visitBinaryExpression_equals', () { | |
| 4200 final __test = new StaticTypeAnalyzerTest(); | |
| 4201 runJUnitTest(__test, __test.test_visitBinaryExpression_equals); | |
| 4202 }); | |
| 4203 _ut.test('test_visitBinaryExpression_logicalAnd', () { | |
| 4204 final __test = new StaticTypeAnalyzerTest(); | |
| 4205 runJUnitTest(__test, __test.test_visitBinaryExpression_logicalAnd); | |
| 4206 }); | |
| 4207 _ut.test('test_visitBinaryExpression_logicalOr', () { | |
| 4208 final __test = new StaticTypeAnalyzerTest(); | |
| 4209 runJUnitTest(__test, __test.test_visitBinaryExpression_logicalOr); | |
| 4210 }); | |
| 4211 _ut.test('test_visitBinaryExpression_notEquals', () { | |
| 4212 final __test = new StaticTypeAnalyzerTest(); | |
| 4213 runJUnitTest(__test, __test.test_visitBinaryExpression_notEquals); | |
| 4214 }); | |
| 4215 _ut.test('test_visitBinaryExpression_plus', () { | |
| 4216 final __test = new StaticTypeAnalyzerTest(); | |
| 4217 runJUnitTest(__test, __test.test_visitBinaryExpression_plus); | |
| 4218 }); | |
| 4219 _ut.test('test_visitBooleanLiteral_false', () { | |
| 4220 final __test = new StaticTypeAnalyzerTest(); | |
| 4221 runJUnitTest(__test, __test.test_visitBooleanLiteral_false); | |
| 4222 }); | |
| 4223 _ut.test('test_visitBooleanLiteral_true', () { | |
| 4224 final __test = new StaticTypeAnalyzerTest(); | |
| 4225 runJUnitTest(__test, __test.test_visitBooleanLiteral_true); | |
| 4226 }); | |
| 4227 _ut.test('test_visitCascadeExpression', () { | |
| 4228 final __test = new StaticTypeAnalyzerTest(); | |
| 4229 runJUnitTest(__test, __test.test_visitCascadeExpression); | |
| 4230 }); | |
| 4231 _ut.test('test_visitConditionalExpression_differentTypes', () { | |
| 4232 final __test = new StaticTypeAnalyzerTest(); | |
| 4233 runJUnitTest(__test, __test.test_visitConditionalExpression_differentTyp
es); | |
| 4234 }); | |
| 4235 _ut.test('test_visitConditionalExpression_sameTypes', () { | |
| 4236 final __test = new StaticTypeAnalyzerTest(); | |
| 4237 runJUnitTest(__test, __test.test_visitConditionalExpression_sameTypes); | |
| 4238 }); | |
| 4239 _ut.test('test_visitDoubleLiteral', () { | |
| 4240 final __test = new StaticTypeAnalyzerTest(); | |
| 4241 runJUnitTest(__test, __test.test_visitDoubleLiteral); | |
| 4242 }); | |
| 4243 _ut.test('test_visitFunctionExpression_named_block', () { | |
| 4244 final __test = new StaticTypeAnalyzerTest(); | |
| 4245 runJUnitTest(__test, __test.test_visitFunctionExpression_named_block); | |
| 4246 }); | |
| 4247 _ut.test('test_visitFunctionExpression_named_expression', () { | |
| 4248 final __test = new StaticTypeAnalyzerTest(); | |
| 4249 runJUnitTest(__test, __test.test_visitFunctionExpression_named_expressio
n); | |
| 4250 }); | |
| 4251 _ut.test('test_visitFunctionExpression_normalAndNamed_block', () { | |
| 4252 final __test = new StaticTypeAnalyzerTest(); | |
| 4253 runJUnitTest(__test, __test.test_visitFunctionExpression_normalAndNamed_
block); | |
| 4254 }); | |
| 4255 _ut.test('test_visitFunctionExpression_normalAndNamed_expression', () { | |
| 4256 final __test = new StaticTypeAnalyzerTest(); | |
| 4257 runJUnitTest(__test, __test.test_visitFunctionExpression_normalAndNamed_
expression); | |
| 4258 }); | |
| 4259 _ut.test('test_visitFunctionExpression_normalAndPositional_block', () { | |
| 4260 final __test = new StaticTypeAnalyzerTest(); | |
| 4261 runJUnitTest(__test, __test.test_visitFunctionExpression_normalAndPositi
onal_block); | |
| 4262 }); | |
| 4263 _ut.test('test_visitFunctionExpression_normalAndPositional_expression', ()
{ | |
| 4264 final __test = new StaticTypeAnalyzerTest(); | |
| 4265 runJUnitTest(__test, __test.test_visitFunctionExpression_normalAndPositi
onal_expression); | |
| 4266 }); | |
| 4267 _ut.test('test_visitFunctionExpression_normal_block', () { | |
| 4268 final __test = new StaticTypeAnalyzerTest(); | |
| 4269 runJUnitTest(__test, __test.test_visitFunctionExpression_normal_block); | |
| 4270 }); | |
| 4271 _ut.test('test_visitFunctionExpression_normal_expression', () { | |
| 4272 final __test = new StaticTypeAnalyzerTest(); | |
| 4273 runJUnitTest(__test, __test.test_visitFunctionExpression_normal_expressi
on); | |
| 4274 }); | |
| 4275 _ut.test('test_visitFunctionExpression_positional_block', () { | |
| 4276 final __test = new StaticTypeAnalyzerTest(); | |
| 4277 runJUnitTest(__test, __test.test_visitFunctionExpression_positional_bloc
k); | |
| 4278 }); | |
| 4279 _ut.test('test_visitFunctionExpression_positional_expression', () { | |
| 4280 final __test = new StaticTypeAnalyzerTest(); | |
| 4281 runJUnitTest(__test, __test.test_visitFunctionExpression_positional_expr
ession); | |
| 4282 }); | |
| 4283 _ut.test('test_visitIndexExpression_getter', () { | |
| 4284 final __test = new StaticTypeAnalyzerTest(); | |
| 4285 runJUnitTest(__test, __test.test_visitIndexExpression_getter); | |
| 4286 }); | |
| 4287 _ut.test('test_visitIndexExpression_setter', () { | |
| 4288 final __test = new StaticTypeAnalyzerTest(); | |
| 4289 runJUnitTest(__test, __test.test_visitIndexExpression_setter); | |
| 4290 }); | |
| 4291 _ut.test('test_visitInstanceCreationExpression_named', () { | |
| 4292 final __test = new StaticTypeAnalyzerTest(); | |
| 4293 runJUnitTest(__test, __test.test_visitInstanceCreationExpression_named); | |
| 4294 }); | |
| 4295 _ut.test('test_visitInstanceCreationExpression_typeParameters', () { | |
| 4296 final __test = new StaticTypeAnalyzerTest(); | |
| 4297 runJUnitTest(__test, __test.test_visitInstanceCreationExpression_typePar
ameters); | |
| 4298 }); | |
| 4299 _ut.test('test_visitInstanceCreationExpression_unnamed', () { | |
| 4300 final __test = new StaticTypeAnalyzerTest(); | |
| 4301 runJUnitTest(__test, __test.test_visitInstanceCreationExpression_unnamed
); | |
| 4302 }); | |
| 4303 _ut.test('test_visitIntegerLiteral', () { | |
| 4304 final __test = new StaticTypeAnalyzerTest(); | |
| 4305 runJUnitTest(__test, __test.test_visitIntegerLiteral); | |
| 4306 }); | |
| 4307 _ut.test('test_visitIsExpression_negated', () { | |
| 4308 final __test = new StaticTypeAnalyzerTest(); | |
| 4309 runJUnitTest(__test, __test.test_visitIsExpression_negated); | |
| 4310 }); | |
| 4311 _ut.test('test_visitIsExpression_notNegated', () { | |
| 4312 final __test = new StaticTypeAnalyzerTest(); | |
| 4313 runJUnitTest(__test, __test.test_visitIsExpression_notNegated); | |
| 4314 }); | |
| 4315 _ut.test('test_visitListLiteral_empty', () { | |
| 4316 final __test = new StaticTypeAnalyzerTest(); | |
| 4317 runJUnitTest(__test, __test.test_visitListLiteral_empty); | |
| 4318 }); | |
| 4319 _ut.test('test_visitListLiteral_nonEmpty', () { | |
| 4320 final __test = new StaticTypeAnalyzerTest(); | |
| 4321 runJUnitTest(__test, __test.test_visitListLiteral_nonEmpty); | |
| 4322 }); | |
| 4323 _ut.test('test_visitMapLiteral_empty', () { | |
| 4324 final __test = new StaticTypeAnalyzerTest(); | |
| 4325 runJUnitTest(__test, __test.test_visitMapLiteral_empty); | |
| 4326 }); | |
| 4327 _ut.test('test_visitMapLiteral_nonEmpty', () { | |
| 4328 final __test = new StaticTypeAnalyzerTest(); | |
| 4329 runJUnitTest(__test, __test.test_visitMapLiteral_nonEmpty); | |
| 4330 }); | |
| 4331 _ut.test('test_visitNamedExpression', () { | |
| 4332 final __test = new StaticTypeAnalyzerTest(); | |
| 4333 runJUnitTest(__test, __test.test_visitNamedExpression); | |
| 4334 }); | |
| 4335 _ut.test('test_visitNullLiteral', () { | |
| 4336 final __test = new StaticTypeAnalyzerTest(); | |
| 4337 runJUnitTest(__test, __test.test_visitNullLiteral); | |
| 4338 }); | |
| 4339 _ut.test('test_visitParenthesizedExpression', () { | |
| 4340 final __test = new StaticTypeAnalyzerTest(); | |
| 4341 runJUnitTest(__test, __test.test_visitParenthesizedExpression); | |
| 4342 }); | |
| 4343 _ut.test('test_visitPostfixExpression_minusMinus', () { | |
| 4344 final __test = new StaticTypeAnalyzerTest(); | |
| 4345 runJUnitTest(__test, __test.test_visitPostfixExpression_minusMinus); | |
| 4346 }); | |
| 4347 _ut.test('test_visitPostfixExpression_plusPlus', () { | |
| 4348 final __test = new StaticTypeAnalyzerTest(); | |
| 4349 runJUnitTest(__test, __test.test_visitPostfixExpression_plusPlus); | |
| 4350 }); | |
| 4351 _ut.test('test_visitPrefixExpression_bang', () { | |
| 4352 final __test = new StaticTypeAnalyzerTest(); | |
| 4353 runJUnitTest(__test, __test.test_visitPrefixExpression_bang); | |
| 4354 }); | |
| 4355 _ut.test('test_visitPrefixExpression_minus', () { | |
| 4356 final __test = new StaticTypeAnalyzerTest(); | |
| 4357 runJUnitTest(__test, __test.test_visitPrefixExpression_minus); | |
| 4358 }); | |
| 4359 _ut.test('test_visitPrefixExpression_minusMinus', () { | |
| 4360 final __test = new StaticTypeAnalyzerTest(); | |
| 4361 runJUnitTest(__test, __test.test_visitPrefixExpression_minusMinus); | |
| 4362 }); | |
| 4363 _ut.test('test_visitPrefixExpression_not', () { | |
| 4364 final __test = new StaticTypeAnalyzerTest(); | |
| 4365 runJUnitTest(__test, __test.test_visitPrefixExpression_not); | |
| 4366 }); | |
| 4367 _ut.test('test_visitPrefixExpression_plusPlus', () { | |
| 4368 final __test = new StaticTypeAnalyzerTest(); | |
| 4369 runJUnitTest(__test, __test.test_visitPrefixExpression_plusPlus); | |
| 4370 }); | |
| 4371 _ut.test('test_visitPrefixExpression_tilde', () { | |
| 4372 final __test = new StaticTypeAnalyzerTest(); | |
| 4373 runJUnitTest(__test, __test.test_visitPrefixExpression_tilde); | |
| 4374 }); | |
| 4375 _ut.test('test_visitPrefixedIdentifier_getter', () { | |
| 4376 final __test = new StaticTypeAnalyzerTest(); | |
| 4377 runJUnitTest(__test, __test.test_visitPrefixedIdentifier_getter); | |
| 4378 }); | |
| 4379 _ut.test('test_visitPrefixedIdentifier_setter', () { | |
| 4380 final __test = new StaticTypeAnalyzerTest(); | |
| 4381 runJUnitTest(__test, __test.test_visitPrefixedIdentifier_setter); | |
| 4382 }); | |
| 4383 _ut.test('test_visitPrefixedIdentifier_variable', () { | |
| 4384 final __test = new StaticTypeAnalyzerTest(); | |
| 4385 runJUnitTest(__test, __test.test_visitPrefixedIdentifier_variable); | |
| 4386 }); | |
| 4387 _ut.test('test_visitPropertyAccess_getter', () { | |
| 4388 final __test = new StaticTypeAnalyzerTest(); | |
| 4389 runJUnitTest(__test, __test.test_visitPropertyAccess_getter); | |
| 4390 }); | |
| 4391 _ut.test('test_visitPropertyAccess_setter', () { | |
| 4392 final __test = new StaticTypeAnalyzerTest(); | |
| 4393 runJUnitTest(__test, __test.test_visitPropertyAccess_setter); | |
| 4394 }); | |
| 4395 _ut.test('test_visitSimpleStringLiteral', () { | |
| 4396 final __test = new StaticTypeAnalyzerTest(); | |
| 4397 runJUnitTest(__test, __test.test_visitSimpleStringLiteral); | |
| 4398 }); | |
| 4399 _ut.test('test_visitStringInterpolation', () { | |
| 4400 final __test = new StaticTypeAnalyzerTest(); | |
| 4401 runJUnitTest(__test, __test.test_visitStringInterpolation); | |
| 4402 }); | |
| 4403 _ut.test('test_visitSuperExpression', () { | |
| 4404 final __test = new StaticTypeAnalyzerTest(); | |
| 4405 runJUnitTest(__test, __test.test_visitSuperExpression); | |
| 4406 }); | |
| 4407 _ut.test('test_visitThisExpression', () { | |
| 4408 final __test = new StaticTypeAnalyzerTest(); | |
| 4409 runJUnitTest(__test, __test.test_visitThisExpression); | |
| 4410 }); | |
| 4411 _ut.test('test_visitThrowExpression_withValue', () { | |
| 4412 final __test = new StaticTypeAnalyzerTest(); | |
| 4413 runJUnitTest(__test, __test.test_visitThrowExpression_withValue); | |
| 4414 }); | |
| 4415 _ut.test('test_visitThrowExpression_withoutValue', () { | |
| 4416 final __test = new StaticTypeAnalyzerTest(); | |
| 4417 runJUnitTest(__test, __test.test_visitThrowExpression_withoutValue); | |
| 4418 }); | |
| 4419 }); | |
| 4420 } | |
| 4421 } | |
| 4422 class EnclosedScopeTest extends ResolverTestCase { | |
| 4423 void test_define_duplicate() { | |
| 4424 LibraryElement definingLibrary2 = createTestLibrary(); | |
| 4425 GatheringErrorListener errorListener2 = new GatheringErrorListener(); | |
| 4426 Scope rootScope = new Scope_10(definingLibrary2, errorListener2); | |
| 4427 EnclosedScope scope = new EnclosedScope(rootScope); | |
| 4428 VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v1")); | |
| 4429 VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v1")); | |
| 4430 scope.define(element1); | |
| 4431 scope.define(element2); | |
| 4432 errorListener2.assertErrors3([ErrorSeverity.ERROR]); | |
| 4433 } | |
| 4434 void test_define_normal() { | |
| 4435 LibraryElement definingLibrary3 = createTestLibrary(); | |
| 4436 GatheringErrorListener errorListener3 = new GatheringErrorListener(); | |
| 4437 Scope rootScope = new Scope_11(definingLibrary3, errorListener3); | |
| 4438 EnclosedScope outerScope = new EnclosedScope(rootScope); | |
| 4439 EnclosedScope innerScope = new EnclosedScope(outerScope); | |
| 4440 VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v1")); | |
| 4441 VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v2")); | |
| 4442 outerScope.define(element1); | |
| 4443 innerScope.define(element2); | |
| 4444 errorListener3.assertNoErrors(); | |
| 4445 } | |
| 4446 static dartSuite() { | |
| 4447 _ut.group('EnclosedScopeTest', () { | |
| 4448 _ut.test('test_define_duplicate', () { | |
| 4449 final __test = new EnclosedScopeTest(); | |
| 4450 runJUnitTest(__test, __test.test_define_duplicate); | |
| 4451 }); | |
| 4452 _ut.test('test_define_normal', () { | |
| 4453 final __test = new EnclosedScopeTest(); | |
| 4454 runJUnitTest(__test, __test.test_define_normal); | |
| 4455 }); | |
| 4456 }); | |
| 4457 } | |
| 4458 } | |
| 4459 class Scope_10 extends Scope { | |
| 4460 LibraryElement definingLibrary2; | |
| 4461 GatheringErrorListener errorListener2; | |
| 4462 Scope_10(this.definingLibrary2, this.errorListener2) : super(); | |
| 4463 LibraryElement get definingLibrary => definingLibrary2; | |
| 4464 AnalysisErrorListener get errorListener => errorListener2; | |
| 4465 Element lookup3(String name, LibraryElement referencingLibrary) => null; | |
| 4466 } | |
| 4467 class Scope_11 extends Scope { | |
| 4468 LibraryElement definingLibrary3; | |
| 4469 GatheringErrorListener errorListener3; | |
| 4470 Scope_11(this.definingLibrary3, this.errorListener3) : super(); | |
| 4471 LibraryElement get definingLibrary => definingLibrary3; | |
| 4472 AnalysisErrorListener get errorListener => errorListener3; | |
| 4473 Element lookup3(String name, LibraryElement referencingLibrary) => null; | |
| 4474 } | |
| 4475 class LibraryElementBuilderTest extends EngineTestCase { | |
| 4476 /** | |
| 4477 * The source factory used to create {@link Source sources}. | |
| 4478 */ | |
| 4479 SourceFactory _sourceFactory; | |
| 4480 void setUp() { | |
| 4481 _sourceFactory = new SourceFactory.con2([new FileUriResolver()]); | |
| 4482 } | |
| 4483 void test_empty() { | |
| 4484 Source librarySource = addSource("/lib.dart", "library lib;"); | |
| 4485 LibraryElement element = buildLibrary(librarySource, []); | |
| 4486 JUnitTestCase.assertNotNull(element); | |
| 4487 JUnitTestCase.assertEquals("lib", element.name); | |
| 4488 JUnitTestCase.assertNull(element.entryPoint); | |
| 4489 EngineTestCase.assertLength(0, element.importedLibraries); | |
| 4490 EngineTestCase.assertLength(0, element.imports); | |
| 4491 JUnitTestCase.assertNull(element.library); | |
| 4492 EngineTestCase.assertLength(0, element.prefixes); | |
| 4493 EngineTestCase.assertLength(0, element.parts); | |
| 4494 CompilationUnitElement unit = element.definingCompilationUnit; | |
| 4495 JUnitTestCase.assertNotNull(unit); | |
| 4496 JUnitTestCase.assertEquals("lib.dart", unit.name); | |
| 4497 JUnitTestCase.assertEquals(element, unit.library); | |
| 4498 EngineTestCase.assertLength(0, unit.accessors); | |
| 4499 EngineTestCase.assertLength(0, unit.functions); | |
| 4500 EngineTestCase.assertLength(0, unit.typeAliases); | |
| 4501 EngineTestCase.assertLength(0, unit.types); | |
| 4502 EngineTestCase.assertLength(0, unit.topLevelVariables); | |
| 4503 } | |
| 4504 void test_invalidUri_part() { | |
| 4505 Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["
library lib;", "", "part '\${'a'}.dart';"])); | |
| 4506 LibraryElement element = buildLibrary(librarySource, [CompileTimeErrorCode.U
RI_WITH_INTERPOLATION]); | |
| 4507 JUnitTestCase.assertNotNull(element); | |
| 4508 } | |
| 4509 void test_missingLibraryDirectiveWithPart() { | |
| 4510 addSource("/a.dart", EngineTestCase.createSource(["part of lib;"])); | |
| 4511 Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["
part 'a.dart';"])); | |
| 4512 LibraryElement element = buildLibrary(librarySource, [ResolverErrorCode.MISS
ING_LIBRARY_DIRECTIVE_WITH_PART]); | |
| 4513 JUnitTestCase.assertNotNull(element); | |
| 4514 } | |
| 4515 void test_missingPartOfDirective() { | |
| 4516 addSource("/a.dart", "class A {}"); | |
| 4517 Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["
library lib;", "", "part 'a.dart';"])); | |
| 4518 LibraryElement element = buildLibrary(librarySource, [ResolverErrorCode.MISS
ING_PART_OF_DIRECTIVE]); | |
| 4519 JUnitTestCase.assertNotNull(element); | |
| 4520 } | |
| 4521 void test_multipleFiles() { | |
| 4522 Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["
library lib;", "part 'first.dart';", "part 'second.dart';", "", "class A {}"])); | |
| 4523 addSource("/first.dart", EngineTestCase.createSource(["part of lib;", "class
B {}"])); | |
| 4524 addSource("/second.dart", EngineTestCase.createSource(["part of lib;", "clas
s C {}"])); | |
| 4525 LibraryElement element = buildLibrary(librarySource, []); | |
| 4526 JUnitTestCase.assertNotNull(element); | |
| 4527 List<CompilationUnitElement> sourcedUnits = element.parts; | |
| 4528 EngineTestCase.assertLength(2, sourcedUnits); | |
| 4529 assertTypes(element.definingCompilationUnit, ["A"]); | |
| 4530 if (sourcedUnits[0].name == "first.dart") { | |
| 4531 assertTypes(sourcedUnits[0], ["B"]); | |
| 4532 assertTypes(sourcedUnits[1], ["C"]); | |
| 4533 } else { | |
| 4534 assertTypes(sourcedUnits[0], ["C"]); | |
| 4535 assertTypes(sourcedUnits[1], ["B"]); | |
| 4536 } | |
| 4537 } | |
| 4538 void test_singleFile() { | |
| 4539 Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["
library lib;", "", "class A {}"])); | |
| 4540 LibraryElement element = buildLibrary(librarySource, []); | |
| 4541 JUnitTestCase.assertNotNull(element); | |
| 4542 assertTypes(element.definingCompilationUnit, ["A"]); | |
| 4543 } | |
| 4544 /** | |
| 4545 * Add a source file to the content provider. The file path should be absolute
. | |
| 4546 * @param filePath the path of the file being added | |
| 4547 * @param contents the contents to be returned by the content provider for the
specified file | |
| 4548 * @return the source object representing the added file | |
| 4549 */ | |
| 4550 Source addSource(String filePath, String contents) { | |
| 4551 Source source = new FileBasedSource.con1(_sourceFactory, FileUtilities2.crea
teFile(filePath)); | |
| 4552 _sourceFactory.setContents(source, contents); | |
| 4553 return source; | |
| 4554 } | |
| 4555 /** | |
| 4556 * Ensure that there are elements representing all of the types in the given a
rray of type names. | |
| 4557 * @param unit the compilation unit containing the types | |
| 4558 * @param typeNames the names of the types that should be found | |
| 4559 */ | |
| 4560 void assertTypes(CompilationUnitElement unit, List<String> typeNames) { | |
| 4561 JUnitTestCase.assertNotNull(unit); | |
| 4562 List<ClassElement> types3 = unit.types; | |
| 4563 EngineTestCase.assertLength(typeNames.length, types3); | |
| 4564 for (ClassElement type in types3) { | |
| 4565 JUnitTestCase.assertNotNull(type); | |
| 4566 String actualTypeName = type.name; | |
| 4567 bool wasExpected = false; | |
| 4568 for (String expectedTypeName in typeNames) { | |
| 4569 if (expectedTypeName == actualTypeName) { | |
| 4570 wasExpected = true; | |
| 4571 } | |
| 4572 } | |
| 4573 if (!wasExpected) { | |
| 4574 JUnitTestCase.fail("Found unexpected type ${actualTypeName}"); | |
| 4575 } | |
| 4576 } | |
| 4577 } | |
| 4578 /** | |
| 4579 * Build the element model for the library whose defining compilation unit has
the given source. | |
| 4580 * @param librarySource the source of the defining compilation unit for the li
brary | |
| 4581 * @param expectedErrorCodes the errors that are expected to be found while bu
ilding the element | |
| 4582 * model | |
| 4583 * @return the element model that was built for the library | |
| 4584 * @throws Exception if the element model could not be built | |
| 4585 */ | |
| 4586 LibraryElement buildLibrary(Source librarySource, List<ErrorCode> expectedErro
rCodes) { | |
| 4587 AnalysisContextImpl context = new AnalysisContextImpl(); | |
| 4588 context.sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.
defaultSdk), new FileUriResolver()]); | |
| 4589 GatheringErrorListener listener = new GatheringErrorListener(); | |
| 4590 LibraryResolver resolver = new LibraryResolver.con2(context, listener); | |
| 4591 LibraryElementBuilder builder = new LibraryElementBuilder(resolver); | |
| 4592 Library library = resolver.createLibrary(librarySource) as Library; | |
| 4593 LibraryElement element = builder.buildLibrary(library); | |
| 4594 listener.assertErrors2(expectedErrorCodes); | |
| 4595 return element; | |
| 4596 } | |
| 4597 static dartSuite() { | |
| 4598 _ut.group('LibraryElementBuilderTest', () { | |
| 4599 _ut.test('test_empty', () { | |
| 4600 final __test = new LibraryElementBuilderTest(); | |
| 4601 runJUnitTest(__test, __test.test_empty); | |
| 4602 }); | |
| 4603 _ut.test('test_invalidUri_part', () { | |
| 4604 final __test = new LibraryElementBuilderTest(); | |
| 4605 runJUnitTest(__test, __test.test_invalidUri_part); | |
| 4606 }); | |
| 4607 _ut.test('test_missingLibraryDirectiveWithPart', () { | |
| 4608 final __test = new LibraryElementBuilderTest(); | |
| 4609 runJUnitTest(__test, __test.test_missingLibraryDirectiveWithPart); | |
| 4610 }); | |
| 4611 _ut.test('test_missingPartOfDirective', () { | |
| 4612 final __test = new LibraryElementBuilderTest(); | |
| 4613 runJUnitTest(__test, __test.test_missingPartOfDirective); | |
| 4614 }); | |
| 4615 _ut.test('test_multipleFiles', () { | |
| 4616 final __test = new LibraryElementBuilderTest(); | |
| 4617 runJUnitTest(__test, __test.test_multipleFiles); | |
| 4618 }); | |
| 4619 _ut.test('test_singleFile', () { | |
| 4620 final __test = new LibraryElementBuilderTest(); | |
| 4621 runJUnitTest(__test, __test.test_singleFile); | |
| 4622 }); | |
| 4623 }); | |
| 4624 } | |
| 4625 } | |
| 4626 class ScopeTest extends ResolverTestCase { | |
| 4627 void test_define_duplicate() { | |
| 4628 LibraryElement definingLibrary = createTestLibrary(); | |
| 4629 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 4630 ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorLi
stener); | |
| 4631 VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v1")); | |
| 4632 VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v1")); | |
| 4633 scope.define(element1); | |
| 4634 scope.define(element2); | |
| 4635 errorListener.assertErrors3([ErrorSeverity.ERROR]); | |
| 4636 } | |
| 4637 void test_define_normal() { | |
| 4638 LibraryElement definingLibrary = createTestLibrary(); | |
| 4639 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 4640 ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorLi
stener); | |
| 4641 VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v1")); | |
| 4642 VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.id
entifier2("v2")); | |
| 4643 scope.define(element1); | |
| 4644 scope.define(element2); | |
| 4645 errorListener.assertNoErrors(); | |
| 4646 } | |
| 4647 void test_getDefiningLibrary() { | |
| 4648 LibraryElement definingLibrary = createTestLibrary(); | |
| 4649 Scope scope = new ScopeTest_TestScope(definingLibrary, null); | |
| 4650 JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary); | |
| 4651 } | |
| 4652 void test_getErrorListener() { | |
| 4653 LibraryElement definingLibrary = new LibraryElementImpl(new AnalysisContextI
mpl(), ASTFactory.libraryIdentifier2(["test"])); | |
| 4654 GatheringErrorListener errorListener = new GatheringErrorListener(); | |
| 4655 Scope scope = new ScopeTest_TestScope(definingLibrary, errorListener); | |
| 4656 JUnitTestCase.assertEquals(errorListener, scope.errorListener); | |
| 4657 } | |
| 4658 void test_isPrivateName_nonPrivate() { | |
| 4659 JUnitTestCase.assertFalse(Scope.isPrivateName("Public")); | |
| 4660 } | |
| 4661 void test_isPrivateName_private() { | |
| 4662 JUnitTestCase.assertTrue(Scope.isPrivateName("_Private")); | |
| 4663 } | |
| 4664 static dartSuite() { | |
| 4665 _ut.group('ScopeTest', () { | |
| 4666 _ut.test('test_define_duplicate', () { | |
| 4667 final __test = new ScopeTest(); | |
| 4668 runJUnitTest(__test, __test.test_define_duplicate); | |
| 4669 }); | |
| 4670 _ut.test('test_define_normal', () { | |
| 4671 final __test = new ScopeTest(); | |
| 4672 runJUnitTest(__test, __test.test_define_normal); | |
| 4673 }); | |
| 4674 _ut.test('test_getDefiningLibrary', () { | |
| 4675 final __test = new ScopeTest(); | |
| 4676 runJUnitTest(__test, __test.test_getDefiningLibrary); | |
| 4677 }); | |
| 4678 _ut.test('test_getErrorListener', () { | |
| 4679 final __test = new ScopeTest(); | |
| 4680 runJUnitTest(__test, __test.test_getErrorListener); | |
| 4681 }); | |
| 4682 _ut.test('test_isPrivateName_nonPrivate', () { | |
| 4683 final __test = new ScopeTest(); | |
| 4684 runJUnitTest(__test, __test.test_isPrivateName_nonPrivate); | |
| 4685 }); | |
| 4686 _ut.test('test_isPrivateName_private', () { | |
| 4687 final __test = new ScopeTest(); | |
| 4688 runJUnitTest(__test, __test.test_isPrivateName_private); | |
| 4689 }); | |
| 4690 }); | |
| 4691 } | |
| 4692 } | |
| 4693 /** | |
| 4694 * A non-abstract subclass that can be used for testing purposes. | |
| 4695 */ | |
| 4696 class ScopeTest_TestScope extends Scope { | |
| 4697 /** | |
| 4698 * The element representing the library in which this scope is enclosed. | |
| 4699 */ | |
| 4700 LibraryElement _definingLibrary; | |
| 4701 /** | |
| 4702 * The listener that is to be informed when an error is encountered. | |
| 4703 */ | |
| 4704 AnalysisErrorListener _errorListener; | |
| 4705 ScopeTest_TestScope(LibraryElement definingLibrary, AnalysisErrorListener erro
rListener) { | |
| 4706 this._definingLibrary = definingLibrary; | |
| 4707 this._errorListener = errorListener; | |
| 4708 } | |
| 4709 LibraryElement get definingLibrary => _definingLibrary; | |
| 4710 AnalysisErrorListener get errorListener => _errorListener; | |
| 4711 Element lookup3(String name, LibraryElement referencingLibrary) => localLookup
(name, referencingLibrary); | |
| 4712 } | |
| 4713 class SimpleResolverTest extends ResolverTestCase { | |
| 4714 void fail_caseExpressionTypeImplementsEquals_Object() { | |
| 4715 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
IntWrapper {", " final int value;", " const IntWrapper(this.value);", "}", "",
"f(IntWrapper intWrapper) {", " switch(intWrapper) {", " case(const IntWrap
per(1)) : return 1;", " default: return 0;", " }", "}"])); | |
| 4716 resolve(source, []); | |
| 4717 assertNoErrors(); | |
| 4718 verify([source]); | |
| 4719 } | |
| 4720 void fail_staticInvocation() { | |
| 4721 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static int get g => (a,b) => 0;", "}", "class B {", " f() {", " A.g
(1,0);", " }", "}"])); | |
| 4722 resolve(source, []); | |
| 4723 assertNoErrors(); | |
| 4724 verify([source]); | |
| 4725 } | |
| 4726 void test_argumentDefinitionTestNonParameter_formalParameter() { | |
| 4727 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var
v) {", " return ?v;", "}"])); | |
| 4728 resolve(source, []); | |
| 4729 assertNoErrors(); | |
| 4730 verify([source]); | |
| 4731 } | |
| 4732 void test_argumentDefinitionTestNonParameter_namedParameter() { | |
| 4733 Source source = addSource("/test.dart", EngineTestCase.createSource(["f({var
v : 0}) {", " return ?v;", "}"])); | |
| 4734 resolve(source, []); | |
| 4735 assertNoErrors(); | |
| 4736 verify([source]); | |
| 4737 } | |
| 4738 void test_argumentDefinitionTestNonParameter_optionalParameter() { | |
| 4739 Source source = addSource("/test.dart", EngineTestCase.createSource(["f([var
v]) {", " return ?v;", "}"])); | |
| 4740 resolve(source, []); | |
| 4741 assertNoErrors(); | |
| 4742 verify([source]); | |
| 4743 } | |
| 4744 void test_breakWithoutLabelInSwitch() { | |
| 4745 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " void m(int i) {", " switch (i) {", " case 0:", " break;"
, " }", " }", "}"])); | |
| 4746 resolve(source, []); | |
| 4747 assertNoErrors(); | |
| 4748 verify([source]); | |
| 4749 } | |
| 4750 void test_builtInIdentifierAsType_dynamic() { | |
| 4751 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " dynamic x;", "}"])); | |
| 4752 resolve(source, []); | |
| 4753 assertNoErrors(); | |
| 4754 verify([source]); | |
| 4755 } | |
| 4756 void test_caseExpressionTypeImplementsEquals_int() { | |
| 4757 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int
i) {", " switch(i) {", " case(1) : return 1;", " default: return 0;", "
}", "}"])); | |
| 4758 resolve(source, []); | |
| 4759 assertNoErrors(); | |
| 4760 verify([source]); | |
| 4761 } | |
| 4762 void test_caseExpressionTypeImplementsEquals_String() { | |
| 4763 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(Stri
ng s) {", " switch(s) {", " case('1') : return 1;", " default: return 0;"
, " }", "}"])); | |
| 4764 resolve(source, []); | |
| 4765 assertNoErrors(); | |
| 4766 verify([source]); | |
| 4767 } | |
| 4768 void test_class_extends_implements() { | |
| 4769 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends B implements C {}", "class B {}", "class C {}"])); | |
| 4770 resolve(source, []); | |
| 4771 assertNoErrors(); | |
| 4772 verify([source]); | |
| 4773 } | |
| 4774 void test_constConstructorWithNonFinalField_const() { | |
| 4775 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " const int x;", " const A() {}", "}"])); | |
| 4776 resolve(source, []); | |
| 4777 assertNoErrors(); | |
| 4778 verify([source]); | |
| 4779 } | |
| 4780 void test_constConstructorWithNonFinalField_final() { | |
| 4781 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " final int x;", " const A() {}", "}"])); | |
| 4782 resolve(source, []); | |
| 4783 assertNoErrors(); | |
| 4784 verify([source]); | |
| 4785 } | |
| 4786 void test_duplicateDefinition_getter() { | |
| 4787 Source source = addSource("/test.dart", EngineTestCase.createSource(["bool g
et a => true;"])); | |
| 4788 resolve(source, []); | |
| 4789 assertNoErrors(); | |
| 4790 verify([source]); | |
| 4791 } | |
| 4792 void test_empty() { | |
| 4793 Source source = addSource("/test.dart", ""); | |
| 4794 resolve(source, []); | |
| 4795 assertNoErrors(); | |
| 4796 verify([source]); | |
| 4797 } | |
| 4798 void test_forEachLoops_nonConflicting() { | |
| 4799 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " List list = [1,2,3];", " for (int x in list) {}", " for (int x in list) {
}", "}"])); | |
| 4800 resolve(source, []); | |
| 4801 assertNoErrors(); | |
| 4802 verify([source]); | |
| 4803 } | |
| 4804 void test_forLoops_nonConflicting() { | |
| 4805 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " for (int i = 0; i < 3; i++) {", " }", " for (int i = 0; i < 3; i++) {", "
}", "}"])); | |
| 4806 resolve(source, []); | |
| 4807 assertNoErrors(); | |
| 4808 verify([source]); | |
| 4809 } | |
| 4810 void test_functionTypeAlias() { | |
| 4811 Source source = addSource("/test.dart", EngineTestCase.createSource(["typede
f bool P(e);", "class A {", " P p;", " m(e) {", " if (p(e)) {}", " }", "}"
])); | |
| 4812 resolve(source, []); | |
| 4813 assertNoErrors(); | |
| 4814 verify([source]); | |
| 4815 } | |
| 4816 void test_getterAndSetterWithDifferentTypes() { | |
| 4817 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " int get f => 0;", " void set f(String s) {}", "}", "g (A a) {", " a.f
= a.f.toString();", "}"])); | |
| 4818 resolve(source, []); | |
| 4819 assertNoErrors(); | |
| 4820 verify([source]); | |
| 4821 } | |
| 4822 void test_invalidAssignment() { | |
| 4823 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " var x;", " var y;", " x = y;", "}"])); | |
| 4824 resolve(source, []); | |
| 4825 assertNoErrors(); | |
| 4826 verify([source]); | |
| 4827 } | |
| 4828 void test_invalidAssignment_toDynamic() { | |
| 4829 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " var g;", " g = () => 0;", "}"])); | |
| 4830 resolve(source, []); | |
| 4831 assertNoErrors(); | |
| 4832 verify([source]); | |
| 4833 } | |
| 4834 void test_invocationOfNonFunction_dynamic() { | |
| 4835 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " var f;", "}", "class B extends A {", " g() {", " f();", " }", "}"]
)); | |
| 4836 resolve(source, []); | |
| 4837 assertNoErrors(); | |
| 4838 verify([source]); | |
| 4839 } | |
| 4840 void test_invocationOfNonFunction_getter() { | |
| 4841 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " var g;", "}", "f() {", " A a;", " a.g();", "}"])); | |
| 4842 resolve(source, []); | |
| 4843 assertNoErrors(); | |
| 4844 verify([source]); | |
| 4845 } | |
| 4846 void test_invocationOfNonFunction_localVariable() { | |
| 4847 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " var g;", " g();", "}"])); | |
| 4848 resolve(source, []); | |
| 4849 assertNoErrors(); | |
| 4850 verify([source]); | |
| 4851 } | |
| 4852 void test_isValidMixin_badSuperclass() { | |
| 4853 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A extends B {}", "class B {}"])); | |
| 4854 LibraryElement library = resolve(source, []); | |
| 4855 JUnitTestCase.assertNotNull(library); | |
| 4856 CompilationUnitElement unit = library.definingCompilationUnit; | |
| 4857 JUnitTestCase.assertNotNull(unit); | |
| 4858 List<ClassElement> classes = unit.types; | |
| 4859 EngineTestCase.assertLength(2, classes); | |
| 4860 JUnitTestCase.assertFalse(classes[0].isValidMixin()); | |
| 4861 assertNoErrors(); | |
| 4862 verify([source]); | |
| 4863 } | |
| 4864 void test_isValidMixin_constructor() { | |
| 4865 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " A() {}", "}"])); | |
| 4866 LibraryElement library = resolve(source, []); | |
| 4867 JUnitTestCase.assertNotNull(library); | |
| 4868 CompilationUnitElement unit = library.definingCompilationUnit; | |
| 4869 JUnitTestCase.assertNotNull(unit); | |
| 4870 List<ClassElement> classes = unit.types; | |
| 4871 EngineTestCase.assertLength(1, classes); | |
| 4872 JUnitTestCase.assertFalse(classes[0].isValidMixin()); | |
| 4873 assertNoErrors(); | |
| 4874 verify([source]); | |
| 4875 } | |
| 4876 void test_isValidMixin_super() { | |
| 4877 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " toString() {", " return super.toString();", " }", "}"])); | |
| 4878 LibraryElement library = resolve(source, []); | |
| 4879 JUnitTestCase.assertNotNull(library); | |
| 4880 CompilationUnitElement unit = library.definingCompilationUnit; | |
| 4881 JUnitTestCase.assertNotNull(unit); | |
| 4882 List<ClassElement> classes = unit.types; | |
| 4883 EngineTestCase.assertLength(1, classes); | |
| 4884 JUnitTestCase.assertFalse(classes[0].isValidMixin()); | |
| 4885 assertNoErrors(); | |
| 4886 verify([source]); | |
| 4887 } | |
| 4888 void test_isValidMixin_valid() { | |
| 4889 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}"])); | |
| 4890 LibraryElement library = resolve(source, []); | |
| 4891 JUnitTestCase.assertNotNull(library); | |
| 4892 CompilationUnitElement unit = library.definingCompilationUnit; | |
| 4893 JUnitTestCase.assertNotNull(unit); | |
| 4894 List<ClassElement> classes = unit.types; | |
| 4895 EngineTestCase.assertLength(1, classes); | |
| 4896 JUnitTestCase.assertTrue(classes[0].isValidMixin()); | |
| 4897 assertNoErrors(); | |
| 4898 verify([source]); | |
| 4899 } | |
| 4900 void test_methodCascades() { | |
| 4901 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " void m1() {}", " void m2() {}", " void m() {", " A a = new A();",
" a..m1()", " ..m2();", " }", "}"])); | |
| 4902 resolve(source, []); | |
| 4903 assertNoErrors(); | |
| 4904 verify([source]); | |
| 4905 } | |
| 4906 void test_methodCascades_withSetter() { | |
| 4907 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " String name;", " void m1() {}", " void m2() {}", " void m() {", "
A a = new A();", " a..m1()", " ..name = 'name'", " ..m2();", " }",
"}"])); | |
| 4908 resolve(source, []); | |
| 4909 assertNoErrors(); | |
| 4910 verify([source]); | |
| 4911 } | |
| 4912 void test_newWithAbstractClass_factory() { | |
| 4913 Source source = addSource("/test.dart", EngineTestCase.createSource(["abstra
ct class A {", " factory A() { return new B(); }", "}", "class B implements A {
", " B() {}", "}", "A f() {", " return new A();", "}"])); | |
| 4914 resolve(source, []); | |
| 4915 assertNoErrors(); | |
| 4916 verify([source]); | |
| 4917 } | |
| 4918 void test_nonBoolExpression_assert_bool() { | |
| 4919 Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {"
, " assert(true);", "}"])); | |
| 4920 resolve(source, []); | |
| 4921 assertNoErrors(); | |
| 4922 verify([source]); | |
| 4923 } | |
| 4924 void test_nonBoolExpression_assert_functionType() { | |
| 4925 Source source = addSource("/test.dart", EngineTestCase.createSource(["bool m
akeAssertion() => true;", "f() {", " assert(makeAssertion);", "}"])); | |
| 4926 resolve(source, []); | |
| 4927 assertNoErrors(); | |
| 4928 verify([source]); | |
| 4929 } | |
| 4930 void test_resolveAgainstNull() { | |
| 4931 Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var
p) {", " return null == p;", "}"])); | |
| 4932 resolve(source, []); | |
| 4933 assertNoErrors(); | |
| 4934 verify([source]); | |
| 4935 } | |
| 4936 void test_returnOfInvalidType_dynamic() { | |
| 4937 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {", " static void testLogicalOp() {", " testOr(a, b, onTypeError) {", "
try {", " return a || b;", " } on TypeError catch (t) {", "
return onTypeError;", " }", " }", " }", "}"])); | |
| 4938 resolve(source, []); | |
| 4939 assertNoErrors(); | |
| 4940 verify([source]); | |
| 4941 } | |
| 4942 void test_returnOfInvalidType_subtype() { | |
| 4943 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {}", "A f(B b) { return b; }"])); | |
| 4944 resolve(source, []); | |
| 4945 assertNoErrors(); | |
| 4946 verify([source]); | |
| 4947 } | |
| 4948 void test_returnOfInvalidType_supertype() { | |
| 4949 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {}", "B f(A a) { return a; }"])); | |
| 4950 resolve(source, []); | |
| 4951 assertNoErrors(); | |
| 4952 verify([source]); | |
| 4953 } | |
| 4954 void test_typeArgumentNotMatchingBounds_const() { | |
| 4955 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {}", "class G<E extends A> {", " const G() {}", "}",
"f() { return const G<B>(); }"])); | |
| 4956 resolve(source, []); | |
| 4957 assertNoErrors(); | |
| 4958 verify([source]); | |
| 4959 } | |
| 4960 void test_typeArgumentNotMatchingBounds_new() { | |
| 4961 Source source = addSource("/test.dart", EngineTestCase.createSource(["class
A {}", "class B extends A {}", "class G<E extends A> {}", "f() { return new G<B>
(); }"])); | |
| 4962 resolve(source, []); | |
| 4963 assertNoErrors(); | |
| 4964 verify([source]); | |
| 4965 } | |
| 4966 static dartSuite() { | |
| 4967 _ut.group('SimpleResolverTest', () { | |
| 4968 _ut.test('test_argumentDefinitionTestNonParameter_formalParameter', () { | |
| 4969 final __test = new SimpleResolverTest(); | |
| 4970 runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_form
alParameter); | |
| 4971 }); | |
| 4972 _ut.test('test_argumentDefinitionTestNonParameter_namedParameter', () { | |
| 4973 final __test = new SimpleResolverTest(); | |
| 4974 runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_name
dParameter); | |
| 4975 }); | |
| 4976 _ut.test('test_argumentDefinitionTestNonParameter_optionalParameter', () { | |
| 4977 final __test = new SimpleResolverTest(); | |
| 4978 runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_opti
onalParameter); | |
| 4979 }); | |
| 4980 _ut.test('test_breakWithoutLabelInSwitch', () { | |
| 4981 final __test = new SimpleResolverTest(); | |
| 4982 runJUnitTest(__test, __test.test_breakWithoutLabelInSwitch); | |
| 4983 }); | |
| 4984 _ut.test('test_builtInIdentifierAsType_dynamic', () { | |
| 4985 final __test = new SimpleResolverTest(); | |
| 4986 runJUnitTest(__test, __test.test_builtInIdentifierAsType_dynamic); | |
| 4987 }); | |
| 4988 _ut.test('test_caseExpressionTypeImplementsEquals_String', () { | |
| 4989 final __test = new SimpleResolverTest(); | |
| 4990 runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_Stri
ng); | |
| 4991 }); | |
| 4992 _ut.test('test_caseExpressionTypeImplementsEquals_int', () { | |
| 4993 final __test = new SimpleResolverTest(); | |
| 4994 runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_int)
; | |
| 4995 }); | |
| 4996 _ut.test('test_class_extends_implements', () { | |
| 4997 final __test = new SimpleResolverTest(); | |
| 4998 runJUnitTest(__test, __test.test_class_extends_implements); | |
| 4999 }); | |
| 5000 _ut.test('test_constConstructorWithNonFinalField_const', () { | |
| 5001 final __test = new SimpleResolverTest(); | |
| 5002 runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_const
); | |
| 5003 }); | |
| 5004 _ut.test('test_constConstructorWithNonFinalField_final', () { | |
| 5005 final __test = new SimpleResolverTest(); | |
| 5006 runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_final
); | |
| 5007 }); | |
| 5008 _ut.test('test_duplicateDefinition_getter', () { | |
| 5009 final __test = new SimpleResolverTest(); | |
| 5010 runJUnitTest(__test, __test.test_duplicateDefinition_getter); | |
| 5011 }); | |
| 5012 _ut.test('test_empty', () { | |
| 5013 final __test = new SimpleResolverTest(); | |
| 5014 runJUnitTest(__test, __test.test_empty); | |
| 5015 }); | |
| 5016 _ut.test('test_forEachLoops_nonConflicting', () { | |
| 5017 final __test = new SimpleResolverTest(); | |
| 5018 runJUnitTest(__test, __test.test_forEachLoops_nonConflicting); | |
| 5019 }); | |
| 5020 _ut.test('test_forLoops_nonConflicting', () { | |
| 5021 final __test = new SimpleResolverTest(); | |
| 5022 runJUnitTest(__test, __test.test_forLoops_nonConflicting); | |
| 5023 }); | |
| 5024 _ut.test('test_functionTypeAlias', () { | |
| 5025 final __test = new SimpleResolverTest(); | |
| 5026 runJUnitTest(__test, __test.test_functionTypeAlias); | |
| 5027 }); | |
| 5028 _ut.test('test_getterAndSetterWithDifferentTypes', () { | |
| 5029 final __test = new SimpleResolverTest(); | |
| 5030 runJUnitTest(__test, __test.test_getterAndSetterWithDifferentTypes); | |
| 5031 }); | |
| 5032 _ut.test('test_invalidAssignment', () { | |
| 5033 final __test = new SimpleResolverTest(); | |
| 5034 runJUnitTest(__test, __test.test_invalidAssignment); | |
| 5035 }); | |
| 5036 _ut.test('test_invalidAssignment_toDynamic', () { | |
| 5037 final __test = new SimpleResolverTest(); | |
| 5038 runJUnitTest(__test, __test.test_invalidAssignment_toDynamic); | |
| 5039 }); | |
| 5040 _ut.test('test_invocationOfNonFunction_dynamic', () { | |
| 5041 final __test = new SimpleResolverTest(); | |
| 5042 runJUnitTest(__test, __test.test_invocationOfNonFunction_dynamic); | |
| 5043 }); | |
| 5044 _ut.test('test_invocationOfNonFunction_getter', () { | |
| 5045 final __test = new SimpleResolverTest(); | |
| 5046 runJUnitTest(__test, __test.test_invocationOfNonFunction_getter); | |
| 5047 }); | |
| 5048 _ut.test('test_invocationOfNonFunction_localVariable', () { | |
| 5049 final __test = new SimpleResolverTest(); | |
| 5050 runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable); | |
| 5051 }); | |
| 5052 _ut.test('test_isValidMixin_badSuperclass', () { | |
| 5053 final __test = new SimpleResolverTest(); | |
| 5054 runJUnitTest(__test, __test.test_isValidMixin_badSuperclass); | |
| 5055 }); | |
| 5056 _ut.test('test_isValidMixin_constructor', () { | |
| 5057 final __test = new SimpleResolverTest(); | |
| 5058 runJUnitTest(__test, __test.test_isValidMixin_constructor); | |
| 5059 }); | |
| 5060 _ut.test('test_isValidMixin_super', () { | |
| 5061 final __test = new SimpleResolverTest(); | |
| 5062 runJUnitTest(__test, __test.test_isValidMixin_super); | |
| 5063 }); | |
| 5064 _ut.test('test_isValidMixin_valid', () { | |
| 5065 final __test = new SimpleResolverTest(); | |
| 5066 runJUnitTest(__test, __test.test_isValidMixin_valid); | |
| 5067 }); | |
| 5068 _ut.test('test_methodCascades', () { | |
| 5069 final __test = new SimpleResolverTest(); | |
| 5070 runJUnitTest(__test, __test.test_methodCascades); | |
| 5071 }); | |
| 5072 _ut.test('test_methodCascades_withSetter', () { | |
| 5073 final __test = new SimpleResolverTest(); | |
| 5074 runJUnitTest(__test, __test.test_methodCascades_withSetter); | |
| 5075 }); | |
| 5076 _ut.test('test_newWithAbstractClass_factory', () { | |
| 5077 final __test = new SimpleResolverTest(); | |
| 5078 runJUnitTest(__test, __test.test_newWithAbstractClass_factory); | |
| 5079 }); | |
| 5080 _ut.test('test_nonBoolExpression_assert_bool', () { | |
| 5081 final __test = new SimpleResolverTest(); | |
| 5082 runJUnitTest(__test, __test.test_nonBoolExpression_assert_bool); | |
| 5083 }); | |
| 5084 _ut.test('test_nonBoolExpression_assert_functionType', () { | |
| 5085 final __test = new SimpleResolverTest(); | |
| 5086 runJUnitTest(__test, __test.test_nonBoolExpression_assert_functionType); | |
| 5087 }); | |
| 5088 _ut.test('test_resolveAgainstNull', () { | |
| 5089 final __test = new SimpleResolverTest(); | |
| 5090 runJUnitTest(__test, __test.test_resolveAgainstNull); | |
| 5091 }); | |
| 5092 _ut.test('test_returnOfInvalidType_dynamic', () { | |
| 5093 final __test = new SimpleResolverTest(); | |
| 5094 runJUnitTest(__test, __test.test_returnOfInvalidType_dynamic); | |
| 5095 }); | |
| 5096 _ut.test('test_returnOfInvalidType_subtype', () { | |
| 5097 final __test = new SimpleResolverTest(); | |
| 5098 runJUnitTest(__test, __test.test_returnOfInvalidType_subtype); | |
| 5099 }); | |
| 5100 _ut.test('test_returnOfInvalidType_supertype', () { | |
| 5101 final __test = new SimpleResolverTest(); | |
| 5102 runJUnitTest(__test, __test.test_returnOfInvalidType_supertype); | |
| 5103 }); | |
| 5104 _ut.test('test_typeArgumentNotMatchingBounds_const', () { | |
| 5105 final __test = new SimpleResolverTest(); | |
| 5106 runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const); | |
| 5107 }); | |
| 5108 _ut.test('test_typeArgumentNotMatchingBounds_new', () { | |
| 5109 final __test = new SimpleResolverTest(); | |
| 5110 runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new); | |
| 5111 }); | |
| 5112 }); | |
| 5113 } | |
| 5114 } | |
| 5115 main() { | |
| 5116 /*ElementResolverTest.dartSuite(); | |
| 5117 LibraryElementBuilderTest.dartSuite(); | |
| 5118 LibraryTest.dartSuite(); | |
| 5119 StaticTypeAnalyzerTest.dartSuite(); | |
| 5120 TypeProviderImplTest.dartSuite(); | |
| 5121 TypeResolverVisitorTest.dartSuite(); | |
| 5122 EnclosedScopeTest.dartSuite(); | |
| 5123 LibraryImportScopeTest.dartSuite(); | |
| 5124 LibraryScopeTest.dartSuite(); | |
| 5125 ScopeTest.dartSuite(); | |
| 5126 CompileTimeErrorCodeTest.dartSuite(); | |
| 5127 ErrorResolverTest.dartSuite(); | |
| 5128 SimpleResolverTest.dartSuite(); | |
| 5129 StaticTypeWarningCodeTest.dartSuite(); | |
| 5130 StaticWarningCodeTest.dartSuite();*/ | |
| 5131 } | |
| OLD | NEW |