Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1241)

Side by Side Diff: analyzer/lib/src/generated/incremental_resolution_validator.dart

Issue 1400473008: Roll Observatory packages and add a roll script (Closed) Base URL: git@github.com:dart-lang/observatory_pub_packages.git@master
Patch Set: Created 5 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file.
4
5 library engine.incremental_resolution_validator;
6
7 import 'package:analyzer/src/generated/ast.dart';
8 import 'package:analyzer/src/generated/element.dart';
9
10 /**
11 * Validates that the [actual] and the [expected] units have the same structure
12 * and resolution. Throws [IncrementalResolutionMismatch] otherwise.
13 */
14 void assertSameResolution(CompilationUnit actual, CompilationUnit expected,
15 {bool validateTypes: false}) {
16 _SameResolutionValidator validator =
17 new _SameResolutionValidator(validateTypes, expected);
18 actual.accept(validator);
19 }
20
21 /**
22 * This exception is thrown when a mismatch between actual and expected AST
23 * or resolution is found.
24 */
25 class IncrementalResolutionMismatch {
26 final String message;
27 IncrementalResolutionMismatch(this.message);
28 }
29
30 class _SameResolutionValidator implements AstVisitor {
31 final bool validateTypes;
32 AstNode other;
33
34 _SameResolutionValidator(this.validateTypes, this.other);
35
36 @override
37 visitAdjacentStrings(AdjacentStrings node) {}
38
39 @override
40 visitAnnotation(Annotation node) {
41 Annotation other = this.other;
42 _visitNode(node.name, other.name);
43 _visitNode(node.constructorName, other.constructorName);
44 _visitNode(node.arguments, other.arguments);
45 _verifyElement(node.element, other.element);
46 }
47
48 @override
49 visitArgumentList(ArgumentList node) {
50 ArgumentList other = this.other;
51 _visitList(node.arguments, other.arguments);
52 }
53
54 @override
55 visitAsExpression(AsExpression node) {
56 AsExpression other = this.other;
57 _visitExpression(node, other);
58 _visitNode(node.expression, other.expression);
59 _visitNode(node.type, other.type);
60 }
61
62 @override
63 visitAssertStatement(AssertStatement node) {
64 AssertStatement other = this.other;
65 _visitNode(node.condition, other.condition);
66 }
67
68 @override
69 visitAssignmentExpression(AssignmentExpression node) {
70 AssignmentExpression other = this.other;
71 _visitExpression(node, other);
72 _verifyElement(node.staticElement, other.staticElement);
73 _verifyElement(node.propagatedElement, other.propagatedElement);
74 _visitNode(node.leftHandSide, other.leftHandSide);
75 _visitNode(node.rightHandSide, other.rightHandSide);
76 }
77
78 @override
79 visitAwaitExpression(AwaitExpression node) {
80 AwaitExpression other = this.other;
81 _visitExpression(node, other);
82 _visitNode(node.expression, other.expression);
83 }
84
85 @override
86 visitBinaryExpression(BinaryExpression node) {
87 BinaryExpression other = this.other;
88 _visitExpression(node, other);
89 _verifyElement(node.staticElement, other.staticElement);
90 _verifyElement(node.propagatedElement, other.propagatedElement);
91 _visitNode(node.leftOperand, other.leftOperand);
92 _visitNode(node.rightOperand, other.rightOperand);
93 }
94
95 @override
96 visitBlock(Block node) {
97 Block other = this.other;
98 _visitList(node.statements, other.statements);
99 }
100
101 @override
102 visitBlockFunctionBody(BlockFunctionBody node) {
103 BlockFunctionBody other = this.other;
104 _visitNode(node.block, other.block);
105 }
106
107 @override
108 visitBooleanLiteral(BooleanLiteral node) {
109 BooleanLiteral other = this.other;
110 _visitExpression(node, other);
111 }
112
113 @override
114 visitBreakStatement(BreakStatement node) {
115 BreakStatement other = this.other;
116 _visitNode(node.label, other.label);
117 }
118
119 @override
120 visitCascadeExpression(CascadeExpression node) {
121 CascadeExpression other = this.other;
122 _visitExpression(node, other);
123 _visitNode(node.target, other.target);
124 _visitList(node.cascadeSections, other.cascadeSections);
125 }
126
127 @override
128 visitCatchClause(CatchClause node) {
129 CatchClause other = this.other;
130 _visitNode(node.exceptionType, other.exceptionType);
131 _visitNode(node.exceptionParameter, other.exceptionParameter);
132 _visitNode(node.stackTraceParameter, other.stackTraceParameter);
133 _visitNode(node.body, other.body);
134 }
135
136 @override
137 visitClassDeclaration(ClassDeclaration node) {
138 ClassDeclaration other = this.other;
139 _visitDeclaration(node, other);
140 _visitNode(node.name, other.name);
141 _visitNode(node.typeParameters, other.typeParameters);
142 _visitNode(node.extendsClause, other.extendsClause);
143 _visitNode(node.implementsClause, other.implementsClause);
144 _visitNode(node.withClause, other.withClause);
145 _visitList(node.members, other.members);
146 }
147
148 @override
149 visitClassTypeAlias(ClassTypeAlias node) {
150 ClassTypeAlias other = this.other;
151 _visitDeclaration(node, other);
152 _visitNode(node.name, other.name);
153 _visitNode(node.typeParameters, other.typeParameters);
154 _visitNode(node.superclass, other.superclass);
155 _visitNode(node.withClause, other.withClause);
156 }
157
158 @override
159 visitComment(Comment node) {
160 Comment other = this.other;
161 _visitList(node.references, other.references);
162 }
163
164 @override
165 visitCommentReference(CommentReference node) {
166 CommentReference other = this.other;
167 _visitNode(node.identifier, other.identifier);
168 }
169
170 @override
171 visitCompilationUnit(CompilationUnit node) {
172 CompilationUnit other = this.other;
173 _verifyElement(node.element, other.element);
174 _visitList(node.directives, other.directives);
175 _visitList(node.declarations, other.declarations);
176 }
177
178 @override
179 visitConditionalExpression(ConditionalExpression node) {
180 ConditionalExpression other = this.other;
181 _visitExpression(node, other);
182 _visitNode(node.condition, other.condition);
183 _visitNode(node.thenExpression, other.thenExpression);
184 _visitNode(node.elseExpression, other.elseExpression);
185 }
186
187 @override
188 visitConstructorDeclaration(ConstructorDeclaration node) {
189 ConstructorDeclaration other = this.other;
190 _visitDeclaration(node, other);
191 _visitNode(node.returnType, other.returnType);
192 _visitNode(node.name, other.name);
193 _visitNode(node.parameters, other.parameters);
194 _visitNode(node.redirectedConstructor, other.redirectedConstructor);
195 _visitList(node.initializers, other.initializers);
196 }
197
198 @override
199 visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
200 ConstructorFieldInitializer other = this.other;
201 _visitNode(node.fieldName, other.fieldName);
202 _visitNode(node.expression, other.expression);
203 }
204
205 @override
206 visitConstructorName(ConstructorName node) {
207 ConstructorName other = this.other;
208 _verifyElement(node.staticElement, other.staticElement);
209 _visitNode(node.type, other.type);
210 _visitNode(node.name, other.name);
211 }
212
213 @override
214 visitContinueStatement(ContinueStatement node) {
215 ContinueStatement other = this.other;
216 _visitNode(node.label, other.label);
217 }
218
219 @override
220 visitDeclaredIdentifier(DeclaredIdentifier node) {
221 DeclaredIdentifier other = this.other;
222 _visitNode(node.type, other.type);
223 _visitNode(node.identifier, other.identifier);
224 }
225
226 @override
227 visitDefaultFormalParameter(DefaultFormalParameter node) {
228 DefaultFormalParameter other = this.other;
229 _visitNode(node.parameter, other.parameter);
230 _visitNode(node.defaultValue, other.defaultValue);
231 }
232
233 @override
234 visitDoStatement(DoStatement node) {
235 DoStatement other = this.other;
236 _visitNode(node.condition, other.condition);
237 _visitNode(node.body, other.body);
238 }
239
240 @override
241 visitDoubleLiteral(DoubleLiteral node) {
242 DoubleLiteral other = this.other;
243 _visitExpression(node, other);
244 }
245
246 @override
247 visitEmptyFunctionBody(EmptyFunctionBody node) {}
248
249 @override
250 visitEmptyStatement(EmptyStatement node) {}
251
252 @override
253 visitEnumConstantDeclaration(EnumConstantDeclaration node) {
254 EnumConstantDeclaration other = this.other;
255 _visitDeclaration(node, other);
256 _visitNode(node.name, other.name);
257 }
258
259 @override
260 visitEnumDeclaration(EnumDeclaration node) {
261 EnumDeclaration other = this.other;
262 _visitDeclaration(node, other);
263 _visitNode(node.name, other.name);
264 _visitList(node.constants, other.constants);
265 }
266
267 @override
268 visitExportDirective(ExportDirective node) {
269 ExportDirective other = this.other;
270 _visitDirective(node, other);
271 }
272
273 @override
274 visitExpressionFunctionBody(ExpressionFunctionBody node) {
275 ExpressionFunctionBody other = this.other;
276 _visitNode(node.expression, other.expression);
277 }
278
279 @override
280 visitExpressionStatement(ExpressionStatement node) {
281 ExpressionStatement other = this.other;
282 _visitNode(node.expression, other.expression);
283 }
284
285 @override
286 visitExtendsClause(ExtendsClause node) {
287 ExtendsClause other = this.other;
288 _visitNode(node.superclass, other.superclass);
289 }
290
291 @override
292 visitFieldDeclaration(FieldDeclaration node) {
293 FieldDeclaration other = this.other;
294 _visitDeclaration(node, other);
295 _visitNode(node.fields, other.fields);
296 }
297
298 @override
299 visitFieldFormalParameter(FieldFormalParameter node) {
300 FieldFormalParameter other = this.other;
301 _visitNormalFormalParameter(node, other);
302 _visitNode(node.type, other.type);
303 _visitNode(node.parameters, other.parameters);
304 }
305
306 @override
307 visitForEachStatement(ForEachStatement node) {
308 ForEachStatement other = this.other;
309 _visitNode(node.identifier, other.identifier);
310 _visitNode(node.loopVariable, other.loopVariable);
311 _visitNode(node.iterable, other.iterable);
312 }
313
314 @override
315 visitFormalParameterList(FormalParameterList node) {
316 FormalParameterList other = this.other;
317 _visitList(node.parameters, other.parameters);
318 }
319
320 @override
321 visitForStatement(ForStatement node) {
322 ForStatement other = this.other;
323 _visitNode(node.variables, other.variables);
324 _visitNode(node.initialization, other.initialization);
325 _visitNode(node.condition, other.condition);
326 _visitList(node.updaters, other.updaters);
327 _visitNode(node.body, other.body);
328 }
329
330 @override
331 visitFunctionDeclaration(FunctionDeclaration node) {
332 FunctionDeclaration other = this.other;
333 _visitDeclaration(node, other);
334 _visitNode(node.returnType, other.returnType);
335 _visitNode(node.name, other.name);
336 _visitNode(node.functionExpression, other.functionExpression);
337 }
338
339 @override
340 visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
341 FunctionDeclarationStatement other = this.other;
342 _visitNode(node.functionDeclaration, other.functionDeclaration);
343 }
344
345 @override
346 visitFunctionExpression(FunctionExpression node) {
347 FunctionExpression other = this.other;
348 _visitExpression(node, other);
349 _verifyElement(node.element, other.element);
350 _visitNode(node.parameters, other.parameters);
351 _visitNode(node.body, other.body);
352 }
353
354 @override
355 visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
356 FunctionExpressionInvocation other = this.other;
357 _visitExpression(node, other);
358 _verifyElement(node.staticElement, other.staticElement);
359 _verifyElement(node.propagatedElement, other.propagatedElement);
360 _visitNode(node.function, other.function);
361 _visitNode(node.argumentList, other.argumentList);
362 }
363
364 @override
365 visitFunctionTypeAlias(FunctionTypeAlias node) {
366 FunctionTypeAlias other = this.other;
367 _visitDeclaration(node, other);
368 _visitNode(node.returnType, other.returnType);
369 _visitNode(node.name, other.name);
370 _visitNode(node.typeParameters, other.typeParameters);
371 _visitNode(node.parameters, other.parameters);
372 }
373
374 @override
375 visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
376 FunctionTypedFormalParameter other = this.other;
377 _visitNormalFormalParameter(node, other);
378 _visitNode(node.returnType, other.returnType);
379 _visitNode(node.parameters, other.parameters);
380 }
381
382 @override
383 visitHideCombinator(HideCombinator node) {
384 HideCombinator other = this.other;
385 _visitList(node.hiddenNames, other.hiddenNames);
386 }
387
388 @override
389 visitIfStatement(IfStatement node) {
390 IfStatement other = this.other;
391 _visitNode(node.condition, other.condition);
392 _visitNode(node.thenStatement, other.thenStatement);
393 _visitNode(node.elseStatement, other.elseStatement);
394 }
395
396 @override
397 visitImplementsClause(ImplementsClause node) {
398 ImplementsClause other = this.other;
399 _visitList(node.interfaces, other.interfaces);
400 }
401
402 @override
403 visitImportDirective(ImportDirective node) {
404 ImportDirective other = this.other;
405 _visitDirective(node, other);
406 _visitNode(node.prefix, other.prefix);
407 _verifyElement(node.uriElement, other.uriElement);
408 }
409
410 @override
411 visitIndexExpression(IndexExpression node) {
412 IndexExpression other = this.other;
413 _visitExpression(node, other);
414 _verifyElement(node.staticElement, other.staticElement);
415 _verifyElement(node.propagatedElement, other.propagatedElement);
416 _visitNode(node.target, other.target);
417 _visitNode(node.index, other.index);
418 }
419
420 @override
421 visitInstanceCreationExpression(InstanceCreationExpression node) {
422 InstanceCreationExpression other = this.other;
423 _visitExpression(node, other);
424 _verifyElement(node.staticElement, other.staticElement);
425 _visitNode(node.constructorName, other.constructorName);
426 _visitNode(node.argumentList, other.argumentList);
427 }
428
429 @override
430 visitIntegerLiteral(IntegerLiteral node) {
431 IntegerLiteral other = this.other;
432 _visitExpression(node, other);
433 }
434
435 @override
436 visitInterpolationExpression(InterpolationExpression node) {
437 InterpolationExpression other = this.other;
438 _visitNode(node.expression, other.expression);
439 }
440
441 @override
442 visitInterpolationString(InterpolationString node) {}
443
444 @override
445 visitIsExpression(IsExpression node) {
446 IsExpression other = this.other;
447 _visitExpression(node, other);
448 _visitNode(node.expression, other.expression);
449 _visitNode(node.type, other.type);
450 }
451
452 @override
453 visitLabel(Label node) {
454 Label other = this.other;
455 _visitNode(node.label, other.label);
456 }
457
458 @override
459 visitLabeledStatement(LabeledStatement node) {
460 LabeledStatement other = this.other;
461 _visitList(node.labels, other.labels);
462 _visitNode(node.statement, other.statement);
463 }
464
465 @override
466 visitLibraryDirective(LibraryDirective node) {
467 LibraryDirective other = this.other;
468 _visitDirective(node, other);
469 _visitNode(node.name, other.name);
470 }
471
472 @override
473 visitLibraryIdentifier(LibraryIdentifier node) {
474 LibraryIdentifier other = this.other;
475 _visitList(node.components, other.components);
476 }
477
478 @override
479 visitListLiteral(ListLiteral node) {
480 ListLiteral other = this.other;
481 _visitExpression(node, other);
482 _visitList(node.elements, other.elements);
483 }
484
485 @override
486 visitMapLiteral(MapLiteral node) {
487 MapLiteral other = this.other;
488 _visitExpression(node, other);
489 _visitList(node.entries, other.entries);
490 }
491
492 @override
493 visitMapLiteralEntry(MapLiteralEntry node) {
494 MapLiteralEntry other = this.other;
495 _visitNode(node.key, other.key);
496 _visitNode(node.value, other.value);
497 }
498
499 @override
500 visitMethodDeclaration(MethodDeclaration node) {
501 MethodDeclaration other = this.other;
502 _visitDeclaration(node, other);
503 _visitNode(node.name, other.name);
504 _visitNode(node.parameters, other.parameters);
505 _visitNode(node.body, other.body);
506 }
507
508 @override
509 visitMethodInvocation(MethodInvocation node) {
510 MethodInvocation other = this.other;
511 _visitNode(node.target, other.target);
512 _visitNode(node.methodName, other.methodName);
513 _visitNode(node.argumentList, other.argumentList);
514 }
515
516 @override
517 visitNamedExpression(NamedExpression node) {
518 NamedExpression other = this.other;
519 _visitNode(node.name, other.name);
520 _visitNode(node.expression, other.expression);
521 }
522
523 @override
524 visitNativeClause(NativeClause node) {}
525
526 @override
527 visitNativeFunctionBody(NativeFunctionBody node) {}
528
529 @override
530 visitNullLiteral(NullLiteral node) {
531 NullLiteral other = this.other;
532 _visitExpression(node, other);
533 }
534
535 @override
536 visitParenthesizedExpression(ParenthesizedExpression node) {
537 ParenthesizedExpression other = this.other;
538 _visitNode(node.expression, other.expression);
539 }
540
541 @override
542 visitPartDirective(PartDirective node) {
543 PartDirective other = this.other;
544 _visitDirective(node, other);
545 }
546
547 @override
548 visitPartOfDirective(PartOfDirective node) {
549 PartOfDirective other = this.other;
550 _visitDirective(node, other);
551 _visitNode(node.libraryName, other.libraryName);
552 }
553
554 @override
555 visitPostfixExpression(PostfixExpression node) {
556 PostfixExpression other = this.other;
557 _visitExpression(node, other);
558 _verifyElement(node.staticElement, other.staticElement);
559 _verifyElement(node.propagatedElement, other.propagatedElement);
560 _visitNode(node.operand, other.operand);
561 }
562
563 @override
564 visitPrefixedIdentifier(PrefixedIdentifier node) {
565 PrefixedIdentifier other = this.other;
566 _visitExpression(node, other);
567 _visitNode(node.prefix, other.prefix);
568 _visitNode(node.identifier, other.identifier);
569 }
570
571 @override
572 visitPrefixExpression(PrefixExpression node) {
573 PrefixExpression other = this.other;
574 _visitExpression(node, other);
575 _verifyElement(node.staticElement, other.staticElement);
576 _verifyElement(node.propagatedElement, other.propagatedElement);
577 _visitNode(node.operand, other.operand);
578 }
579
580 @override
581 visitPropertyAccess(PropertyAccess node) {
582 PropertyAccess other = this.other;
583 _visitExpression(node, other);
584 _visitNode(node.target, other.target);
585 _visitNode(node.propertyName, other.propertyName);
586 }
587
588 @override
589 visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
590 RedirectingConstructorInvocation other = this.other;
591 _verifyElement(node.staticElement, other.staticElement);
592 _visitNode(node.constructorName, other.constructorName);
593 _visitNode(node.argumentList, other.argumentList);
594 }
595
596 @override
597 visitRethrowExpression(RethrowExpression node) {
598 RethrowExpression other = this.other;
599 _visitExpression(node, other);
600 }
601
602 @override
603 visitReturnStatement(ReturnStatement node) {
604 ReturnStatement other = this.other;
605 _visitNode(node.expression, other.expression);
606 }
607
608 @override
609 visitScriptTag(ScriptTag node) {}
610
611 @override
612 visitShowCombinator(ShowCombinator node) {
613 ShowCombinator other = this.other;
614 _visitList(node.shownNames, other.shownNames);
615 }
616
617 @override
618 visitSimpleFormalParameter(SimpleFormalParameter node) {
619 SimpleFormalParameter other = this.other;
620 _visitNormalFormalParameter(node, other);
621 _visitNode(node.type, other.type);
622 }
623
624 @override
625 visitSimpleIdentifier(SimpleIdentifier node) {
626 SimpleIdentifier other = this.other;
627 _verifyElement(node.staticElement, other.staticElement);
628 _verifyElement(node.propagatedElement, other.propagatedElement);
629 _visitExpression(node, other);
630 }
631
632 @override
633 visitSimpleStringLiteral(SimpleStringLiteral node) {}
634
635 @override
636 visitStringInterpolation(StringInterpolation node) {
637 StringInterpolation other = this.other;
638 _visitList(node.elements, other.elements);
639 }
640
641 @override
642 visitSuperConstructorInvocation(SuperConstructorInvocation node) {
643 SuperConstructorInvocation other = this.other;
644 _verifyElement(node.staticElement, other.staticElement);
645 _visitNode(node.constructorName, other.constructorName);
646 _visitNode(node.argumentList, other.argumentList);
647 }
648
649 @override
650 visitSuperExpression(SuperExpression node) {
651 SuperExpression other = this.other;
652 _visitExpression(node, other);
653 }
654
655 @override
656 visitSwitchCase(SwitchCase node) {
657 SwitchCase other = this.other;
658 _visitList(node.labels, other.labels);
659 _visitNode(node.expression, other.expression);
660 _visitList(node.statements, other.statements);
661 }
662
663 @override
664 visitSwitchDefault(SwitchDefault node) {
665 SwitchDefault other = this.other;
666 _visitList(node.statements, other.statements);
667 }
668
669 @override
670 visitSwitchStatement(SwitchStatement node) {
671 SwitchStatement other = this.other;
672 _visitNode(node.expression, other.expression);
673 _visitList(node.members, other.members);
674 }
675
676 @override
677 visitSymbolLiteral(SymbolLiteral node) {}
678
679 @override
680 visitThisExpression(ThisExpression node) {
681 ThisExpression other = this.other;
682 _visitExpression(node, other);
683 }
684
685 @override
686 visitThrowExpression(ThrowExpression node) {
687 ThrowExpression other = this.other;
688 _visitNode(node.expression, other.expression);
689 }
690
691 @override
692 visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
693 TopLevelVariableDeclaration other = this.other;
694 _visitNode(node.variables, other.variables);
695 }
696
697 @override
698 visitTryStatement(TryStatement node) {
699 TryStatement other = this.other;
700 _visitNode(node.body, other.body);
701 _visitList(node.catchClauses, other.catchClauses);
702 _visitNode(node.finallyBlock, other.finallyBlock);
703 }
704
705 @override
706 visitTypeArgumentList(TypeArgumentList node) {
707 TypeArgumentList other = this.other;
708 _visitList(node.arguments, other.arguments);
709 }
710
711 @override
712 visitTypeName(TypeName node) {
713 TypeName other = this.other;
714 _verifyType(node.type, other.type);
715 _visitNode(node.name, node.name);
716 _visitNode(node.typeArguments, other.typeArguments);
717 }
718
719 @override
720 visitTypeParameter(TypeParameter node) {
721 TypeParameter other = this.other;
722 _visitNode(node.name, other.name);
723 _visitNode(node.bound, other.bound);
724 }
725
726 @override
727 visitTypeParameterList(TypeParameterList node) {
728 TypeParameterList other = this.other;
729 _visitList(node.typeParameters, other.typeParameters);
730 }
731
732 @override
733 visitVariableDeclaration(VariableDeclaration node) {
734 VariableDeclaration other = this.other;
735 _visitDeclaration(node, other);
736 _visitNode(node.name, other.name);
737 _visitNode(node.initializer, other.initializer);
738 }
739
740 @override
741 visitVariableDeclarationList(VariableDeclarationList node) {
742 VariableDeclarationList other = this.other;
743 _visitNode(node.type, other.type);
744 _visitList(node.variables, other.variables);
745 }
746
747 @override
748 visitVariableDeclarationStatement(VariableDeclarationStatement node) {
749 VariableDeclarationStatement other = this.other;
750 _visitNode(node.variables, other.variables);
751 }
752
753 @override
754 visitWhileStatement(WhileStatement node) {
755 WhileStatement other = this.other;
756 _visitNode(node.condition, other.condition);
757 _visitNode(node.body, other.body);
758 }
759
760 @override
761 visitWithClause(WithClause node) {
762 WithClause other = this.other;
763 _visitList(node.mixinTypes, other.mixinTypes);
764 }
765
766 @override
767 visitYieldStatement(YieldStatement node) {
768 YieldStatement other = this.other;
769 _visitNode(node.expression, other.expression);
770 }
771
772 void _assertNode(AstNode a, AstNode b) {
773 _expectEquals(a.offset, b.offset);
774 _expectEquals(a.length, b.length);
775 }
776
777 void _expectEquals(actual, expected) {
778 if (actual != expected) {
779 String message = '';
780 message += 'Expected: $expected\n';
781 message += ' Actual: $actual\n';
782 _fail(message);
783 }
784 }
785
786 void _expectIsNull(obj) {
787 if (obj != null) {
788 String message = '';
789 message += 'Expected: null\n';
790 message += ' Actual: $obj\n';
791 _fail(message);
792 }
793 }
794
795 void _expectLength(List actualList, int expected) {
796 String message = '';
797 message += 'Expected length: $expected\n';
798 if (actualList == null) {
799 message += 'but null found.';
800 _fail(message);
801 }
802 int actual = actualList.length;
803 if (actual != expected) {
804 message += 'but $actual found\n';
805 message += 'in $actualList';
806 _fail(message);
807 }
808 }
809
810 void _fail(String message) {
811 throw new IncrementalResolutionMismatch(message);
812 }
813
814 void _verifyElement(Element a, Element b) {
815 if (a is Member && b is Member) {
816 a = (a as Member).baseElement;
817 b = (b as Member).baseElement;
818 }
819 String locationA = _getElementLocationWithoutUri(a);
820 String locationB = _getElementLocationWithoutUri(b);
821 if (locationA != locationB) {
822 int offset = other.offset;
823 _fail('[$offset]\nExpected: $b ($locationB)\n Actual: $a ($locationA)');
824 }
825 if (a == null && b == null) {
826 return;
827 }
828 if (a.nameOffset != b.nameOffset) {
829 _fail('Expected: ${b.nameOffset}\n Actual: ${a.nameOffset}');
830 }
831 }
832
833 void _verifyType(DartType a, DartType b) {
834 if (!validateTypes) {
835 return;
836 }
837 if (a != b) {
838 int offset = other.offset;
839 _fail('[$offset]\nExpected: $b\n Actual: $a');
840 }
841 }
842
843 void _visitAnnotatedNode(AnnotatedNode node, AnnotatedNode other) {
844 _visitNode(node.documentationComment, other.documentationComment);
845 _visitList(node.metadata, other.metadata);
846 }
847
848 _visitDeclaration(Declaration node, Declaration other) {
849 _verifyElement(node.element, other.element);
850 _visitAnnotatedNode(node, other);
851 }
852
853 _visitDirective(Directive node, Directive other) {
854 _verifyElement(node.element, other.element);
855 _visitAnnotatedNode(node, other);
856 }
857
858 void _visitExpression(Expression a, Expression b) {
859 // print('[${a.offset}] |$a| vs. [${b.offset}] |$b|');
860 _verifyType(a.staticType, b.staticType);
861 _verifyType(a.propagatedType, b.propagatedType);
862 _verifyElement(a.staticParameterElement, b.staticParameterElement);
863 _verifyElement(a.propagatedParameterElement, b.propagatedParameterElement);
864 _assertNode(a, b);
865 }
866
867 void _visitList(NodeList nodeList, NodeList otherList) {
868 int length = nodeList.length;
869 _expectLength(otherList, length);
870 for (int i = 0; i < length; i++) {
871 _visitNode(nodeList[i], otherList[i]);
872 }
873 }
874
875 void _visitNode(AstNode node, AstNode other) {
876 if (node == null) {
877 _expectIsNull(other);
878 } else {
879 this.other = other;
880 _assertNode(node, other);
881 node.accept(this);
882 }
883 }
884
885 void _visitNormalFormalParameter(
886 NormalFormalParameter node, NormalFormalParameter other) {
887 _verifyElement(node.element, other.element);
888 _visitNode(node.documentationComment, other.documentationComment);
889 _visitList(node.metadata, other.metadata);
890 _visitNode(node.identifier, other.identifier);
891 }
892
893 /**
894 * Returns an URI scheme independent version of the [element] location.
895 */
896 static String _getElementLocationWithoutUri(Element element) {
897 if (element == null) {
898 return '<null>';
899 }
900 if (element is UriReferencedElementImpl) {
901 return '<ignored>';
902 }
903 ElementLocation location = element.location;
904 List<String> components = location.components;
905 String uriPrefix = '';
906 Element unit = element is CompilationUnitElement
907 ? element
908 : element.getAncestor((e) => e is CompilationUnitElement);
909 if (unit != null) {
910 String libComponent = components[0];
911 String unitComponent = components[1];
912 components = components.sublist(2);
913 uriPrefix = _getShortElementLocationUri(libComponent) +
914 ':' +
915 _getShortElementLocationUri(unitComponent);
916 } else {
917 String libComponent = components[0];
918 components = components.sublist(1);
919 uriPrefix = _getShortElementLocationUri(libComponent);
920 }
921 return uriPrefix + ':' + components.join(':');
922 }
923
924 /**
925 * Returns a "short" version of the given [uri].
926 *
927 * For example:
928 * /User/me/project/lib/my_lib.dart -> my_lib.dart
929 * package:project/my_lib.dart -> my_lib.dart
930 */
931 static String _getShortElementLocationUri(String uri) {
932 int index = uri.lastIndexOf('/');
933 if (index == -1) {
934 return uri;
935 }
936 return uri.substring(index + 1);
937 }
938 }
OLDNEW
« no previous file with comments | « analyzer/lib/src/generated/incremental_logger.dart ('k') | analyzer/lib/src/generated/incremental_resolver.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698