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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: pkg/compiler/lib/src/stats/builder.dart

Issue 1385443003: dart2js: rename folder (stats -> info) (Closed) Base URL: git@github.com:dart-lang/sdk.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
« no previous file with comments | « pkg/compiler/lib/src/stats/analysis_result.dart ('k') | pkg/compiler/lib/src/stats/naive_analysis_result.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2015, 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 /// Computes statistical data about a program. See `stats.dart` for more details
6 /// on the kind of data we collect.
7 library compiler.src.stats.stats_builder;
8
9 import 'dart:convert';
10 import 'package:dart2js_info/src/measurements.dart';
11 import 'package:dart2js_info/src/util.dart' show recursiveDiagnosticString;
12
13 import '../diagnostics/messages.dart' show MessageKind;
14 import '../compiler.dart' show Compiler;
15 import '../common/tasks.dart' show CompilerTask;
16 import '../dart_types.dart';
17 import '../closure.dart';
18 import '../elements/elements.dart';
19 import '../elements/visitor.dart' show ElementVisitor;
20 import '../resolution/operators.dart';
21 import '../resolution/semantic_visitor.dart';
22 import '../resolution/send_resolver.dart';
23 import '../resolution/tree_elements.dart';
24 import '../constants/expressions.dart';
25 import '../parser/partial_elements.dart' show PartialElement;
26 import '../tree/tree.dart';
27 import '../universe/selector.dart' show Selector;
28 import '../universe/call_structure.dart' show CallStructure;
29
30 import 'analysis_result.dart';
31 import 'naive_analysis_result.dart';
32 import 'trusted_types_analysis_result.dart';
33
34 /// Collects a set of [Measurements] about send expressions in the function [f].
35 // TODO(sigmund): collect information on initializers too.
36 Measurements collectSendMeasurements(FunctionElement f, Compiler compiler) {
37 return compiler.withCurrentElement(f, () {
38 // TODO(sigmund): enable for platform too.
39 if (f.library.isPlatformLibrary) return;
40 var name = _qualifiedName(f);
41 if (!f.hasNode) {
42 if (f is PartialElement) return const Measurements.unreachableFunction();
43 assert (f is ConstructorElement && f.isSynthesized);
44 // TODO(sigmund): measure synthethic forwarding sends, measure
45 // initializers
46 return new Measurements.reachableFunction();
47 }
48 if (!f.hasResolvedAst) {
49 _debug('no resolved ast ${f.runtimeType}');
50 return null;
51 }
52 var resolvedAst = f.resolvedAst;
53 if (resolvedAst.node == null) {
54 _debug('no node ${f.runtimeType}');
55 return null;
56 }
57 var def = resolvedAst.elements.getFunctionDefinition(resolvedAst.node);
58 if (def == null) {
59 assert (f is PartialElement);
60 return const Measurements.unreachableFunction();
61 }
62
63 var visitor = new _StatsTraversalVisitor(
64 compiler, resolvedAst.elements,
65 compiler.spanFromNode(resolvedAst.node).uri);
66 resolvedAst.node.accept(visitor);
67 return visitor.measurements;
68 });
69 }
70
71 _qualifiedName(FunctionElement f) {
72 var cls = f.enclosingClass;
73 return (cls != null) ? '${cls.name}.${f.name}' : f.name;
74 }
75
76 /// Visitor that categorizes data about an individual send.
77 class _StatsVisitor<T> extends Visitor
78 with SendResolverMixin, SemanticSendResolvedMixin<dynamic, T>
79 implements SemanticSendVisitor<dynamic, T> {
80
81 // TODO(sigmund): consider passing in several AnalysisResults at once, so we
82 // can compute the different metrics together.
83 /// Information we know about the program from static analysis.
84 final AnalysisResult info;
85
86 /// Results from this function.
87 final Measurements measurements;
88
89 final Compiler compiler;
90 final TreeElements elements;
91
92 SemanticSendVisitor<dynamic, T> get sendVisitor => this;
93
94 _StatsVisitor(this.compiler, this.elements, this.info, Uri sourceUri)
95 : measurements = new Measurements.reachableFunction(sourceUri);
96
97 visitNode(Node node) => throw "unhandled ${node.runtimeType}: $node";
98 apply(Node node, T arg) => throw "missing apply ${node.runtimeType}: $node";
99 internalError(Node node, String arg) => throw "internal error on $node";
100
101 visitSend(Send node) {
102 _checkInvariant(node, 'before');
103 var span = compiler.spanFromNode(node);
104 measurements.record(Metric.send, span.begin, span.end);
105 if (node is SendSet) {
106 if ((node.assignmentOperator != null &&
107 node.assignmentOperator.source != '=') ||
108 node.isPrefix ||
109 node.isPostfix) {
110 assert(!node.isIfNullAssignment);
111 // We count get and set separately in case one of them is defined by the
112 // other could be a nSM error.
113 measurements.record(Metric.send, span.begin, span.end);
114 measurements.record(Metric.send, span.begin, span.end);
115 } else if (node.isIfNullAssignment) {
116 measurements.record(Metric.send, span.begin, span.end);
117 }
118 }
119 super.visitSend(node);
120 _checkInvariant(node, 'after ');
121 }
122
123 visitNewExpression(NewExpression node) {
124 _checkInvariant(node, 'before');
125 var span = compiler.spanFromNode(node);
126 measurements.record(Metric.send, span.begin, span.end);
127 super.visitNewExpression(node);
128 _checkInvariant(node, 'after ');
129 }
130
131 /// A monomorphic local variable read.
132 ///
133 /// See [Metric.send] for a full categorization of sends.
134 handleLocal(Node node) {
135 var span = compiler.spanFromNode(node);
136 measurements.record(Metric.monomorphicSend, span.begin, span.end);
137 measurements.record(Metric.localSend, span.begin, span.end);
138 }
139
140 /// A monomorphic virual call on [node], where we know which function is the
141 /// target of the call (for example, because only one type in a class
142 /// hierarchy implements a function with a given name).
143 ///
144 /// See [Metric.send] for a full categorization of sends.
145 handleSingleInstance(Node node) {
146 var span = compiler.spanFromNode(node);
147 measurements.record(Metric.monomorphicSend, span.begin, span.end);
148 measurements.record(Metric.instanceSend, span.begin, span.end);
149 }
150
151 /// A monomorphic call that goes through an interceptor. This is equivalent in
152 /// terms of what the compiler knows as we do with [handleSignleInstance], and
153 /// because we know the target of the call, we also know that it doesn't live
154 /// in the object instance, but on an interceptor on the side.
155 ///
156 /// See [Metric.send] for a full categorization of sends.
157 handleSingleInterceptor(Node node) {
158 var span = compiler.spanFromNode(node);
159 measurements.record(Metric.monomorphicSend, span.begin, span.end);
160 measurements.record(Metric.interceptorSend, span.begin, span.end);
161 }
162
163 /// A polymorphic call that goes through an interceptor.
164 ///
165 /// See [Metric.send] for a full categorization of sends.
166 handleMultiInterceptor(Node node) {
167 var span = compiler.spanFromNode(node);
168 measurements.record(Metric.polymorphicSend, span.begin, span.end);
169 measurements.record(Metric.multiInterceptorSend, span.begin, span.end);
170 }
171
172 handleConstructor(Node node) {
173 var span = compiler.spanFromNode(node);
174 measurements.record(Metric.monomorphicSend, span.begin, span.end);
175 measurements.record(Metric.constructorSend, span.begin, span.end);
176 }
177
178 handleDynamic(Node node) {
179 var span = compiler.spanFromNode(node);
180 measurements.record(Metric.polymorphicSend, span.begin, span.end);
181 measurements.record(Metric.dynamicSend, span.begin, span.end);
182 }
183
184 handleVirtual(Node node) {
185 var span = compiler.spanFromNode(node);
186 measurements.record(Metric.polymorphicSend, span.begin, span.end);
187 measurements.record(Metric.virtualSend, span.begin, span.end);
188 }
189
190 handleNSMError(Node node) {
191 var span = compiler.spanFromNode(node);
192 measurements.record(Metric.monomorphicSend, span.begin, span.end);
193 measurements.record(Metric.nsmErrorSend, span.begin, span.end);
194 }
195
196 handleNSMSingle(Node node) {
197 var span = compiler.spanFromNode(node);
198 measurements.record(Metric.monomorphicSend, span.begin, span.end);
199 measurements.record(Metric.singleNsmCallSend, span.begin, span.end);
200 }
201
202 handleNSMSuper(Node node, ClassElement type) {
203 var superclass = type.superclass;
204 var member = superclass.lookupMember('noSuchMethod');
205 if (!member.enclosingClass.isObject) {
206 handleNSMSingle(node);
207 } else {
208 handleNSMError(node);
209 }
210 }
211
212 handleNSMAny(Node node) {
213 var span = compiler.spanFromNode(node);
214 measurements.record(Metric.polymorphicSend, span.begin, span.end);
215 measurements.record(Metric.multiNsmCallSend, span.begin, span.end);
216 }
217
218 handleSuper(Node node) {
219 var span = compiler.spanFromNode(node);
220 measurements.record(Metric.monomorphicSend, span.begin, span.end);
221 measurements.record(Metric.superSend, span.begin, span.end);
222 }
223 handleTypeVariable(Node node) {
224 var span = compiler.spanFromNode(node);
225 measurements.record(Metric.monomorphicSend, span.begin, span.end);
226 measurements.record(Metric.typeVariableSend, span.begin, span.end);
227 }
228 handleStatic(Node node) {
229 var span = compiler.spanFromNode(node);
230 measurements.record(Metric.monomorphicSend, span.begin, span.end);
231 measurements.record(Metric.staticSend, span.begin, span.end);
232 }
233
234 handleNoSend(Node node) {
235 measurements.popLast(Metric.send);
236 }
237
238 void handleDynamicProperty(Node node, Node receiver, Selector selector) {
239 // staticSend: no (automatically)
240 // superSend: no (automatically)
241 // localSend: no (automatically)
242 // constructorSend: no (automatically)
243 // typeVariableSend: no (automatically)
244
245 // nsmErrorSend: receiver has no `selector` nor nSM.
246 // singleNsmCallSend: receiver has no `selector`, but definitely has `nSM`
247 // instanceSend: receiver has `selector`, no need to use an interceptor
248 // interceptorSend: receiver has `selector`, but we know we need an
249 // interceptor to get it
250
251 // multiNsmCallSend: receiver has no `selector`, not sure if receiver has
252 // nSM, or not sure which nSM is called (does this one
253 // matter, or does nSM is treated like an instance method
254 // call)?
255 // virtualSend: receiver has `selector`, we know we do not need an
256 // interceptor, not sure which specific type implements
257 // the selector.
258 // multiInterceptorSend: multiple possible receiver types, all using an
259 // interceptor to get the `selector`, might be
260 // possbile to pick a special selector logic for this
261 // combination?
262 // dynamicSend: any combination of the above.
263
264 ReceiverInfo receiverInfo = info.infoForReceiver(receiver);
265 SelectorInfo selectorInfo = info.infoForSelector(receiver, selector);
266 Boolish hasSelector = selectorInfo.exists;
267 Boolish hasNsm = receiverInfo.hasNoSuchMethod;
268
269 if (hasSelector == Boolish.no) {
270 if (hasNsm == Boolish.no) {
271 handleNSMError(node);
272 } else if (hasNsm == Boolish.yes) {
273 if (receiverInfo.possibleNsmTargets == 1) {
274 handleNSMSingle(node);
275 } else {
276 handleNSMAny(node);
277 }
278 } else {
279 handleDynamic(node);
280 }
281 return;
282 }
283
284 Boolish usesInterceptor = selectorInfo.usesInterceptor;
285 if (hasSelector == Boolish.yes) {
286 if (selectorInfo.isAccurate && selectorInfo.possibleTargets == 1) {
287 assert (usesInterceptor != Boolish.maybe);
288 if (usesInterceptor == Boolish.yes) {
289 handleSingleInterceptor(node);
290 } else {
291 handleSingleInstance(node);
292 }
293 } else {
294 if (usesInterceptor == Boolish.no) {
295 handleVirtual(node);
296 } else if (usesInterceptor == Boolish.yes) {
297 handleMultiInterceptor(node);
298 } else {
299 handleDynamic(node);
300 }
301 }
302 return;
303 }
304 handleDynamic(node);
305 }
306
307 void handleThisProperty(Send node, Selector selector) {
308 handleDynamicProperty(node, node.receiver, selector);
309 }
310
311 void handleIndex(Node node) {
312 handleDynamic(node);
313 }
314
315 void handleOperator(Node node) {
316 handleDynamic(node);
317 }
318
319 void handleInvoke(Node node) {
320 handleDynamic(node);
321 }
322
323 void handleEquals(Node node) {
324 handleDynamic(node);
325 }
326
327 // Constructors
328
329 void visitAbstractClassConstructorInvoke(NewExpression node,
330 ConstructorElement element, InterfaceType type, NodeList arguments,
331 CallStructure callStructure, T arg) {
332 handleConstructor(node);
333 }
334
335 void visitBoolFromEnvironmentConstructorInvoke(NewExpression node,
336 BoolFromEnvironmentConstantExpression constant, T arg) {
337 handleConstructor(node);
338 }
339
340 void visitConstConstructorInvoke(
341 NewExpression node, ConstructedConstantExpression constant, T arg) {
342 handleConstructor(node);
343 }
344
345 void visitGenerativeConstructorInvoke(NewExpression node,
346 ConstructorElement constructor, InterfaceType type, NodeList arguments,
347 CallStructure callStructure, T arg) {
348 handleConstructor(node);
349 }
350
351 void visitIntFromEnvironmentConstructorInvoke(NewExpression node,
352 IntFromEnvironmentConstantExpression constant, T arg) {
353 handleConstructor(node);
354 }
355
356 void visitRedirectingFactoryConstructorInvoke(NewExpression node,
357 ConstructorElement constructor, InterfaceType type,
358 ConstructorElement effectiveTarget, InterfaceType effectiveTargetType,
359 NodeList arguments, CallStructure callStructure, T arg) {
360 handleConstructor(node);
361 }
362
363 void visitRedirectingGenerativeConstructorInvoke(NewExpression node,
364 ConstructorElement constructor, InterfaceType type, NodeList arguments,
365 CallStructure callStructure, T arg) {
366 handleConstructor(node);
367 }
368
369 void visitStringFromEnvironmentConstructorInvoke(NewExpression node,
370 StringFromEnvironmentConstantExpression constant, T arg) {
371 handleConstructor(node);
372 }
373
374 // Dynamic sends
375
376
377 // TODO(sigmund): many many things to add:
378 // -- support for operators, indexers, etc.
379 // -- logic about nullables
380 // -- int, JSArray
381 // -- all interceptors
382
383 void visitBinary(
384 Send node, Node left, BinaryOperator operator, Node right, T arg) {
385 handleOperator(node);
386 }
387
388 void visitCompoundIndexSet(SendSet node, Node receiver, Node index,
389 AssignmentOperator operator, Node rhs, T arg) {
390 handleIndex(node); // t1 = receiver[index]
391 handleOperator(node); // t2 = t1 op rhs
392 handleIndex(node); // receiver[index] = t2
393 }
394
395 void visitDynamicPropertyCompound(Send node, Node receiver,
396 Name name, AssignmentOperator operator, Node rhs, T arg) {
397 handleDynamicProperty(node, receiver, new Selector.getter(name));
398 handleOperator(node);
399 handleDynamicProperty(node, receiver, new Selector.setter(name));
400 }
401
402
403 void visitDynamicPropertyGet(
404 Send node, Node receiver, Name name, T arg) {
405 handleDynamicProperty(node, receiver, new Selector.getter(name));
406 }
407
408 void visitDynamicPropertyInvoke(
409 Send node, Node receiver, NodeList arguments, Selector selector, T arg) {
410 handleDynamicProperty(node, receiver, selector);
411 }
412
413 void visitDynamicPropertyPostfix(Send node, Node receiver,
414 Name name, IncDecOperator operator, T arg) {
415 handleDynamicProperty(node, receiver, new Selector.getter(name));
416 handleOperator(node);
417 handleDynamicProperty(node, receiver, new Selector.setter(name));
418 }
419
420 void visitDynamicPropertyPrefix(Send node, Node receiver, Name name,
421 IncDecOperator operator, T arg) {
422 handleDynamicProperty(node, receiver, new Selector.getter(name));
423 handleOperator(node);
424 handleDynamicProperty(node, receiver, new Selector.setter(name));
425 }
426
427 void visitDynamicPropertySet(
428 SendSet node, Node receiver, Name name, Node rhs, T arg) {
429 handleDynamicProperty(node, receiver, new Selector.setter(name));
430 }
431
432 void visitDynamicPropertySetIfNull(
433 Send node, Node receiver, Name name, Node rhs, T arg) {
434 // read to check for null?
435 handleDynamicProperty(node, receiver, new Selector.getter(name));
436 handleDynamicProperty(node, receiver, new Selector.setter(name));
437 }
438
439 void visitEquals(Send node, Node left, Node right, T arg) {
440 handleEquals(node);
441 }
442
443 void visitExpressionInvoke(Send node, Node expression, NodeList arguments,
444 CallStructure callStructure, T arg) {
445 handleInvoke(node);
446 }
447
448 void visitIfNotNullDynamicPropertyCompound(Send node, Node receiver,
449 Name name, AssignmentOperator operator, Node rhs, T arg) {
450 handleDynamicProperty(node, receiver, new Selector.getter(name));
451 handleOperator(node);
452 handleDynamicProperty(node, receiver, new Selector.setter(name));
453 }
454
455 void visitIfNotNullDynamicPropertyGet(
456 Send node, Node receiver, Name name, T arg) {
457 handleDynamicProperty(node, receiver, new Selector.getter(name));
458 }
459
460 void visitIfNotNullDynamicPropertyInvoke(
461 Send node, Node receiver, NodeList arguments, Selector selector, T arg) {
462 handleDynamicProperty(node, receiver, selector);
463 }
464
465 void visitIfNotNullDynamicPropertyPostfix(Send node, Node receiver, Name name,
466 IncDecOperator operator, T arg) {
467 handleDynamicProperty(node, receiver, new Selector.getter(name));
468 handleOperator(node);
469 handleDynamicProperty(node, receiver, new Selector.setter(name));
470 }
471
472 void visitIfNotNullDynamicPropertyPrefix(Send node, Node receiver, Name name,
473 IncDecOperator operator, T arg) {
474 handleDynamicProperty(node, receiver, new Selector.getter(name));
475 handleOperator(node);
476 handleDynamicProperty(node, receiver, new Selector.setter(name));
477 }
478
479 void visitIfNotNullDynamicPropertySet(
480 SendSet node, Node receiver, Name name, Node rhs, T arg) {
481 handleDynamicProperty(node, receiver, new Selector.setter(name));
482 }
483
484 void visitIfNotNullDynamicPropertySetIfNull(
485 Send node, Node receiver, Name name, Node rhs, T arg) {
486 handleDynamicProperty(node, receiver, new Selector.getter(name));
487 handleDynamicProperty(node, receiver, new Selector.setter(name));
488 }
489
490 void visitIndex(Send node, Node receiver, Node index, T arg) {
491 handleIndex(node);
492 }
493
494 void visitIndexPostfix(
495 Send node, Node receiver, Node index, IncDecOperator operator, T arg) {
496 handleIndex(node);
497 handleOperator(node);
498 handleIndex(node);
499 }
500
501 void visitIndexPrefix(
502 Send node, Node receiver, Node index, IncDecOperator operator, T arg) {
503 handleIndex(node);
504 handleOperator(node);
505 handleIndex(node);
506 }
507
508 void visitIndexSet(SendSet node, Node receiver, Node index, Node rhs, T arg) {
509 handleIndex(node);
510 }
511
512 void visitLocalVariableCompound(Send node, LocalVariableElement variable,
513 AssignmentOperator operator, Node rhs, T arg) {
514 handleLocal(node);
515 handleOperator(node);
516 handleLocal(node);
517 }
518
519 void visitLocalVariableInvoke(Send node, LocalVariableElement variable,
520 NodeList arguments, CallStructure callStructure, T arg) {
521 handleInvoke(node);
522 }
523
524 void visitLocalVariablePostfix(Send node, LocalVariableElement variable,
525 IncDecOperator operator, T arg) {
526 handleLocal(node);
527 handleOperator(node);
528 handleLocal(node);
529 }
530
531 void visitLocalVariablePrefix(Send node, LocalVariableElement variable,
532 IncDecOperator operator, T arg) {
533 handleLocal(node);
534 handleOperator(node);
535 handleLocal(node);
536 }
537
538 void visitNotEquals(Send node, Node left, Node right, T arg) {
539 handleEquals(node);
540 }
541
542 void visitParameterCompound(Send node, ParameterElement parameter,
543 AssignmentOperator operator, Node rhs, T arg) {
544 handleLocal(node);
545 handleOperator(node);
546 handleLocal(node);
547 }
548
549 void visitParameterInvoke(Send node, ParameterElement parameter,
550 NodeList arguments, CallStructure callStructure, T arg) {
551 handleInvoke(node);
552 }
553
554 void visitParameterPostfix(
555 Send node, ParameterElement parameter, IncDecOperator operator, T arg) {
556 handleLocal(node);
557 handleOperator(node);
558 handleLocal(node);
559 }
560
561 void visitParameterPrefix(
562 Send node, ParameterElement parameter, IncDecOperator operator, T arg) {
563 handleLocal(node);
564 handleOperator(node);
565 handleLocal(node);
566 }
567
568 void visitStaticFieldCompound(Send node, FieldElement field,
569 AssignmentOperator operator, Node rhs, T arg) {
570 handleStatic(node);
571 handleOperator(node);
572 handleStatic(node);
573 }
574
575 void visitStaticFieldInvoke(Send node, FieldElement field, NodeList arguments,
576 CallStructure callStructure, T arg) {
577 handleInvoke(node);
578 }
579
580 void visitStaticFieldPostfix(
581 Send node, FieldElement field, IncDecOperator operator, T arg) {
582 handleStatic(node);
583 handleOperator(node);
584 handleStatic(node);
585 }
586
587 void visitStaticFieldPrefix(
588 Send node, FieldElement field, IncDecOperator operator, T arg) {
589 handleStatic(node);
590 handleOperator(node);
591 handleStatic(node);
592 }
593
594 void visitStaticGetterInvoke(Send node, FunctionElement getter,
595 NodeList arguments, CallStructure callStructure, T arg) {
596 handleInvoke(node);
597 }
598
599 void visitStaticGetterSetterCompound(Send node, FunctionElement getter,
600 FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
601 handleStatic(node);
602 handleOperator(node);
603 handleStatic(node);
604 }
605
606 void visitStaticGetterSetterPostfix(Send node, FunctionElement getter,
607 FunctionElement setter, IncDecOperator operator, T arg) {
608 handleStatic(node);
609 handleOperator(node);
610 handleStatic(node);
611 }
612
613 void visitStaticGetterSetterPrefix(Send node, FunctionElement getter,
614 FunctionElement setter, IncDecOperator operator, T arg) {
615 handleStatic(node);
616 handleOperator(node);
617 handleStatic(node);
618 }
619
620 void visitSuperFieldCompound(Send node, FieldElement field,
621 AssignmentOperator operator, Node rhs, T arg) {
622 handleSuper(node);
623 handleOperator(node);
624 handleSuper(node);
625 }
626
627 void visitSuperFieldFieldCompound(Send node, FieldElement readField,
628 FieldElement writtenField, AssignmentOperator operator, Node rhs, T arg) {
629 handleSuper(node);
630 handleOperator(node);
631 handleSuper(node);
632 }
633
634 void visitSuperFieldFieldPostfix(Send node, FieldElement readField,
635 FieldElement writtenField, IncDecOperator operator, T arg) {
636 handleSuper(node);
637 handleOperator(node);
638 handleSuper(node);
639 }
640
641 void visitSuperFieldFieldPrefix(Send node, FieldElement readField,
642 FieldElement writtenField, IncDecOperator operator, T arg) {
643 handleSuper(node);
644 handleOperator(node);
645 handleSuper(node);
646 }
647
648 void visitSuperFieldFieldSetIfNull(
649 Send node, FieldElement readField, FieldElement writtenField, Node rhs,
650 T arg) {
651 handleSuper(node);
652 handleNSMSuper(node, readField.enclosingClass);
653 }
654
655 void visitSuperFieldInvoke(Send node, FieldElement field, NodeList arguments,
656 CallStructure callStructure, T arg) {
657 handleInvoke(node);
658 }
659
660 void visitSuperFieldPostfix(
661 Send node, FieldElement field, IncDecOperator operator, T arg) {
662 handleSuper(node);
663 handleOperator(node);
664 handleSuper(node);
665 }
666
667 void visitSuperFieldPrefix(
668 Send node, FieldElement field, IncDecOperator operator, T arg) {
669 handleSuper(node);
670 handleOperator(node);
671 handleSuper(node);
672 }
673
674 void visitSuperFieldSetterCompound(Send node, FieldElement field,
675 FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
676 handleSuper(node);
677 handleOperator(node);
678 handleSuper(node);
679 }
680
681 void visitSuperFieldSetterPostfix(Send node, FieldElement field,
682 FunctionElement setter, IncDecOperator operator, T arg) {
683 handleSuper(node);
684 handleOperator(node);
685 handleSuper(node);
686 }
687
688 void visitSuperFieldSetterPrefix(Send node, FieldElement field,
689 FunctionElement setter, IncDecOperator operator, T arg) {
690 handleSuper(node);
691 handleOperator(node);
692 handleSuper(node);
693 }
694
695 void visitSuperFieldSetterSetIfNull(Send node, FieldElement field,
696 FunctionElement setter, Node rhs, T arg) {
697 handleSuper(node);
698 handleSuper(node);
699 }
700
701 void visitSuperGetterFieldCompound(Send node, FunctionElement getter,
702 FieldElement field, AssignmentOperator operator, Node rhs, T arg) {
703 handleSuper(node);
704 handleOperator(node);
705 handleSuper(node);
706 }
707
708 void visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
709 FieldElement field, IncDecOperator operator, T arg) {
710 handleSuper(node);
711 handleOperator(node);
712 handleSuper(node);
713 }
714
715 void visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
716 FieldElement field, IncDecOperator operator, T arg) {
717 handleSuper(node);
718 handleOperator(node);
719 handleSuper(node);
720 }
721
722 void visitSuperGetterFieldSetIfNull(Send node, FunctionElement getter,
723 FieldElement field, Node rhs, T arg) {
724 handleSuper(node);
725 handleSuper(node);
726 }
727
728 void visitSuperGetterInvoke(Send node, FunctionElement getter,
729 NodeList arguments, CallStructure callStructure, T arg) {
730 handleInvoke(node);
731 }
732
733 void visitSuperGetterSetterCompound(Send node, FunctionElement getter,
734 FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
735 handleSuper(node);
736 handleOperator(node);
737 handleSuper(node);
738 }
739
740 void visitSuperGetterSetterPostfix(Send node, FunctionElement getter,
741 FunctionElement setter, IncDecOperator operator, T arg) {
742 handleSuper(node);
743 handleOperator(node);
744 handleSuper(node);
745 }
746
747 void visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
748 FunctionElement setter, IncDecOperator operator, T arg) {
749 handleSuper(node);
750 handleOperator(node);
751 handleSuper(node);
752 }
753
754 void visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
755 FunctionElement setter, Node rhs, T arg) {
756 handleSuper(node);
757 handleSuper(node);
758 }
759
760 void visitSuperIndexPostfix(Send node, MethodElement indexFunction,
761 MethodElement indexSetFunction, Node index, IncDecOperator operator,
762 T arg) {
763 handleSuper(node);
764 handleOperator(node);
765 handleSuper(node);
766 }
767
768 void visitSuperIndexPrefix(Send node, MethodElement indexFunction,
769 MethodElement indexSetFunction, Node index, IncDecOperator operator,
770 T arg) {
771 handleSuper(node);
772 handleOperator(node);
773 handleSuper(node);
774 }
775
776 void visitSuperMethodSetterCompound(Send node, FunctionElement method,
777 FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
778 handleSuper(node);
779 handleNSMSuper(node, method.enclosingClass);
780 handleSuper(node);
781 }
782
783 void visitSuperMethodSetterPostfix(Send node, FunctionElement method,
784 FunctionElement setter, IncDecOperator operator, T arg) {
785 handleSuper(node);
786 handleNSMSuper(node, method.enclosingClass);
787 handleSuper(node);
788 }
789
790 void visitSuperMethodSetterPrefix(Send node, FunctionElement method,
791 FunctionElement setter, IncDecOperator operator, T arg) {
792 handleSuper(node);
793 handleNSMSuper(node, method.enclosingClass);
794 handleSuper(node);
795 }
796
797 void visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
798 FunctionElement setter, Node rhs, T arg) {
799 handleSuper(node);
800 handleSuper(node);
801 }
802
803 void visitThisPropertyCompound(Send node, Name name,
804 AssignmentOperator operator, Node rhs, T arg) {
805 handleThisProperty(node, new Selector.getter(name));
806 handleOperator(node);
807 handleThisProperty(node, new Selector.setter(name));
808 }
809
810 void visitThisPropertyInvoke(
811 Send node, NodeList arguments, Selector selector, T arg) {
812 handleThisProperty(node, selector);
813 }
814
815 void visitThisPropertyPostfix(Send node, Name name, IncDecOperator operator,
816 T arg) {
817 handleThisProperty(node, new Selector.getter(name));
818 handleOperator(node);
819 handleThisProperty(node, new Selector.setter(name));
820 }
821
822 void visitThisPropertyPrefix(Send node, Name name, IncDecOperator operator,
823 T arg) {
824 handleThisProperty(node, new Selector.getter(name));
825 handleOperator(node);
826 handleThisProperty(node, new Selector.setter(name));
827 }
828
829 void visitTopLevelFieldCompound(Send node, FieldElement field,
830 AssignmentOperator operator, Node rhs, T arg) {
831 handleStatic(node);
832 handleOperator(node);
833 handleStatic(node);
834 }
835
836 void visitTopLevelFieldInvoke(Send node, FieldElement field,
837 NodeList arguments, CallStructure callStructure, T arg) {
838 handleInvoke(node);
839 }
840
841 void visitTopLevelFieldPostfix(
842 Send node, FieldElement field, IncDecOperator operator, T arg) {
843 handleStatic(node);
844 handleOperator(node);
845 handleStatic(node);
846 }
847
848 void visitTopLevelFieldPrefix(
849 Send node, FieldElement field, IncDecOperator operator, T arg) {
850 handleStatic(node);
851 handleOperator(node);
852 handleStatic(node);
853 }
854
855 void visitTopLevelGetterInvoke(Send node, FunctionElement getter,
856 NodeList arguments, CallStructure callStructure, T arg) {
857 handleInvoke(node);
858 }
859
860 void visitTopLevelGetterSetterCompound(Send node, FunctionElement getter,
861 FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
862 handleStatic(node);
863 handleOperator(node);
864 handleStatic(node);
865 }
866
867 void visitTopLevelGetterSetterPostfix(Send node, FunctionElement getter,
868 FunctionElement setter, IncDecOperator operator, T arg) {
869 handleStatic(node);
870 handleOperator(node);
871 handleStatic(node);
872 }
873
874 void visitTopLevelGetterSetterPrefix(Send node, FunctionElement getter,
875 FunctionElement setter, IncDecOperator operator, T arg) {
876 handleStatic(node);
877 handleOperator(node);
878 handleStatic(node);
879 }
880
881 void visitUnary(Send node, UnaryOperator operator, Node expression, T arg) {
882 handleDynamic(node);
883 }
884
885 // Local variable sends
886
887 void visitLocalFunctionGet(Send node, LocalFunctionElement function, T arg) {
888 handleLocal(node);
889 }
890
891 void visitLocalFunctionInvoke(Send node, LocalFunctionElement function,
892 NodeList arguments, CallStructure callStructure, T arg) {
893 handleLocal(node);
894 }
895
896 void visitLocalVariableGet(Send node, LocalVariableElement variable, T arg) {
897 handleLocal(node);
898 }
899
900 void visitLocalVariableSet(
901 SendSet node, LocalVariableElement variable, Node rhs, T arg) {
902 handleLocal(node);
903 }
904
905 void visitLocalVariableSetIfNull(
906 SendSet node, LocalVariableElement variable, Node rhs, T arg) {
907 handleLocal(node);
908 handleLocal(node);
909 }
910
911 void visitParameterGet(Send node, ParameterElement parameter, T arg) {
912 handleLocal(node);
913 }
914
915 void visitParameterSet(
916 SendSet node, ParameterElement parameter, Node rhs, T arg) {
917 handleLocal(node);
918 }
919
920 void visitParameterSetIfNull(
921 Send node, ParameterElement parameter, Node rhs, T arg) {
922 handleLocal(node);
923 handleLocal(node);
924 }
925
926 // Super monomorphic sends
927
928 void visitSuperBinary(Send node, FunctionElement function,
929 BinaryOperator operator, Node argument, T arg) {
930 handleSuper(node);
931 }
932
933 void visitSuperEquals(
934 Send node, FunctionElement function, Node argument, T arg) {
935 handleSuper(node);
936 }
937
938 void visitSuperFieldGet(Send node, FieldElement field, T arg) {
939 handleSuper(node);
940 }
941
942 void visitSuperFieldSet(SendSet node, FieldElement field, Node rhs, T arg) {
943 handleSuper(node);
944 }
945
946 void visitSuperFieldSetIfNull(
947 SendSet node, FieldElement field, Node rhs, T arg) {
948 handleSuper(node);
949 handleSuper(node);
950 }
951
952 void visitSuperGetterGet(Send node, FunctionElement getter, T arg) {
953 handleSuper(node);
954 }
955
956 void visitSuperGetterSet(
957 SendSet node, FunctionElement getter, Node rhs, T arg) {
958 handleSuper(node);
959 }
960
961 void visitSuperIndex(Send node, FunctionElement function, Node index, T arg) {
962 handleSuper(node);
963 }
964
965 void visitSuperIndexSet(
966 SendSet node, FunctionElement function, Node index, Node rhs, T arg) {
967 handleSuper(node);
968 }
969
970 void visitSuperMethodGet(Send node, MethodElement method, T arg) {
971 handleSuper(node);
972 }
973
974 void visitSuperMethodInvoke(Send node, MethodElement method,
975 NodeList arguments, CallStructure callStructure, T arg) {
976 handleSuper(node);
977 }
978
979 void visitSuperNotEquals(
980 Send node, FunctionElement function, Node argument, T arg) {
981 handleSuper(node);
982 }
983
984 void visitSuperSetterSet(
985 SendSet node, FunctionElement setter, Node rhs, T arg) {
986 handleSuper(node);
987 }
988
989 void visitSuperUnary(
990 Send node, UnaryOperator operator, FunctionElement function, T arg) {
991 handleSuper(node);
992 }
993
994 // Statically known "no such method" sends
995
996 void visitConstructorIncompatibleInvoke(NewExpression node,
997 ConstructorElement constructor, InterfaceType type, NodeList arguments,
998 CallStructure callStructure, T arg) {
999 handleNSMError(node);
1000 }
1001
1002 void visitFinalLocalVariableCompound(Send node, LocalVariableElement variable,
1003 AssignmentOperator operator, Node rhs, T arg) {
1004 handleLocal(node);
1005 handleOperator(node);
1006 handleNSMError(node);
1007 }
1008
1009 void visitFinalLocalVariablePostfix(Send node, LocalVariableElement variable,
1010 IncDecOperator operator, T arg) {
1011 handleLocal(node);
1012 handleOperator(node);
1013 handleNSMError(node);
1014 }
1015
1016 void visitFinalLocalVariablePrefix(Send node, LocalVariableElement variable,
1017 IncDecOperator operator, T arg) {
1018 handleLocal(node);
1019 handleOperator(node);
1020 handleNSMError(node);
1021 }
1022
1023 void visitFinalLocalVariableSet(
1024 SendSet node, LocalVariableElement variable, Node rhs, T arg) {
1025 handleNSMError(node);
1026 }
1027
1028 void visitFinalLocalVariableSetIfNull(
1029 SendSet node, LocalVariableElement variable, Node rhs, T arg) {
1030 handleLocal(node); // read for null
1031 handleNSMError(node); // set fails
1032 }
1033
1034 void visitFinalParameterCompound(Send node, ParameterElement parameter,
1035 AssignmentOperator operator, Node rhs, T arg) {
1036 handleLocal(node);
1037 handleOperator(node);
1038 handleNSMError(node);
1039 }
1040
1041 void visitFinalParameterPostfix(
1042 Send node, ParameterElement parameter, IncDecOperator operator, T arg) {
1043 handleLocal(node);
1044 handleOperator(node);
1045 handleNSMError(node);
1046 }
1047
1048 void visitFinalParameterPrefix(
1049 Send node, ParameterElement parameter, IncDecOperator operator, T arg) {
1050 handleLocal(node);
1051 handleOperator(node);
1052 handleNSMError(node);
1053 }
1054
1055 void visitFinalParameterSet(
1056 SendSet node, ParameterElement parameter, Node rhs, T arg) {
1057 handleNSMError(node);
1058 }
1059
1060 void visitFinalParameterSetIfNull(
1061 SendSet node, ParameterElement parameter, Node rhs, T arg) {
1062 handleLocal(node);
1063 handleNSMError(node);
1064 }
1065
1066 void visitFinalStaticFieldCompound(Send node, FieldElement field,
1067 AssignmentOperator operator, Node rhs, T arg) {
1068 handleStatic(node);
1069 handleOperator(node);
1070 handleNSMError(node);
1071 }
1072
1073 void visitFinalStaticFieldPostfix(
1074 Send node, FieldElement field, IncDecOperator operator, T arg) {
1075 handleStatic(node);
1076 handleOperator(node);
1077 handleNSMError(node);
1078 }
1079
1080 void visitFinalStaticFieldPrefix(
1081 Send node, FieldElement field, IncDecOperator operator, T arg) {
1082 handleStatic(node);
1083 handleOperator(node);
1084 handleNSMError(node);
1085 }
1086
1087 void visitFinalStaticFieldSet(
1088 SendSet node, FieldElement field, Node rhs, T arg) {
1089 handleNSMError(node);
1090 }
1091
1092 void visitFinalStaticFieldSetIfNull(
1093 SendSet node, FieldElement field, Node rhs, T arg) {
1094 handleStatic(node);
1095 handleNSMError(node);
1096 }
1097
1098 void visitFinalSuperFieldSetIfNull(Send node, FieldElement field,
1099 Node rhs, T arg) {
1100 handleSuper(node);
1101 handleNSMSuper(node, field.enclosingClass);
1102 }
1103
1104 void visitFinalSuperFieldCompound(Send node, FieldElement field,
1105 AssignmentOperator operator, Node rhs, T arg) {
1106 handleSuper(node);
1107 handleOperator(node);
1108 handleNSMSuper(node, field.enclosingClass);
1109 }
1110
1111 void visitFinalSuperFieldPostfix(
1112 Send node, FieldElement field, IncDecOperator operator, T arg) {
1113 handleSuper(node);
1114 handleOperator(node);
1115 handleNSMSuper(node, field.enclosingClass);
1116 }
1117
1118 void visitFinalSuperFieldPrefix(
1119 Send node, FieldElement field, IncDecOperator operator, T arg) {
1120 handleSuper(node);
1121 handleOperator(node);
1122 handleNSMSuper(node, field.enclosingClass);
1123 }
1124
1125 void visitFinalSuperFieldSet(
1126 SendSet node, FieldElement field, Node rhs, T arg) {
1127 handleNSMSuper(node, field.enclosingClass);
1128 }
1129
1130 void visitFinalTopLevelFieldCompound(Send node, FieldElement field,
1131 AssignmentOperator operator, Node rhs, T arg) {
1132 handleStatic(node);
1133 handleOperator(node);
1134 handleNSMError(node);
1135 }
1136
1137 void visitFinalTopLevelFieldPostfix(
1138 Send node, FieldElement field, IncDecOperator operator, T arg) {
1139 handleStatic(node);
1140 handleOperator(node);
1141 handleNSMError(node);
1142 }
1143
1144 void visitFinalTopLevelFieldPrefix(
1145 Send node, FieldElement field, IncDecOperator operator, T arg) {
1146 handleStatic(node);
1147 handleOperator(node);
1148 handleNSMError(node);
1149 }
1150
1151 void visitFinalTopLevelFieldSet(
1152 SendSet node, FieldElement field, Node rhs, T arg) {
1153 handleNSMError(node);
1154 }
1155
1156 void visitFinalTopLevelFieldSetIfNull(
1157 SendSet node, FieldElement field, Node rhs, T arg) {
1158 handleStatic(node);
1159 handleNSMError(node);
1160 }
1161
1162 void visitTopLevelGetterSetterSetIfNull(Send node, FunctionElement getter,
1163 FunctionElement setter, Node rhs, T arg) {
1164 handleStatic(node);
1165 handleStatic(node);
1166 }
1167
1168 void visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
1169 FunctionElement setter, Node rhs, T arg) {
1170 handleStatic(node);
1171 handleStatic(node);
1172 }
1173
1174 void visitTopLevelMethodSetIfNull(Send node, FunctionElement method,
1175 Node rhs, T arg) {
1176 handleStatic(node);
1177 handleNSMError(node);
1178 }
1179
1180 void visitLocalFunctionIncompatibleInvoke(Send node,
1181 LocalFunctionElement function, NodeList arguments,
1182 CallStructure callStructure, T arg) {
1183 handleNSMError(node);
1184 }
1185
1186 void visitLocalFunctionCompound(Send node, LocalFunctionElement function,
1187 AssignmentOperator operator, Node rhs, T arg) {
1188 handleLocal(node);
1189 handleNSMError(node);
1190 handleNoSend(node);
1191 }
1192
1193 void visitLocalFunctionPostfix(Send node, LocalFunctionElement function,
1194 IncDecOperator operator, T arg) {
1195 handleLocal(node);
1196 handleNSMError(node);
1197 handleNoSend(node);
1198 }
1199
1200 void visitLocalFunctionPrefix(Send node, LocalFunctionElement function,
1201 IncDecOperator operator, T arg) {
1202 handleLocal(node);
1203 handleNSMError(node);
1204 handleNoSend(node);
1205 }
1206
1207 void visitLocalFunctionSet(
1208 SendSet node, LocalFunctionElement function, Node rhs, T arg) {
1209 handleNSMError(node);
1210 }
1211
1212 void visitLocalFunctionSetIfNull(
1213 SendSet node, LocalFunctionElement function, Node rhs, T arg) {
1214 handleLocal(node);
1215 handleNSMError(node);
1216 }
1217
1218 void visitStaticFunctionIncompatibleInvoke(Send node, MethodElement function,
1219 NodeList arguments, CallStructure callStructure, T arg) {
1220 handleNSMError(node);
1221 }
1222
1223 void visitStaticFunctionSet(
1224 Send node, MethodElement function, Node rhs, T arg) {
1225 handleNSMError(node);
1226 }
1227
1228 void visitStaticMethodCompound(Send node, MethodElement method,
1229 AssignmentOperator operator, Node rhs, T arg) {
1230 handleStatic(node);
1231 handleNSMError(node); // operator on a method closure yields nSM
1232 handleNoSend(node); // setter is not invoked, don't count it.
1233 }
1234
1235 void visitStaticMethodPostfix(
1236 Send node, MethodElement method, IncDecOperator operator, T arg) {
1237 handleStatic(node);
1238 handleNSMError(node);
1239 handleNoSend(node);
1240 }
1241
1242 void visitStaticMethodPrefix(
1243 Send node, MethodElement method, IncDecOperator operator, T arg) {
1244 handleStatic(node);
1245 handleNSMError(node);
1246 handleNoSend(node);
1247 }
1248
1249 void visitStaticMethodSetterCompound(Send node, MethodElement method,
1250 MethodElement setter, AssignmentOperator operator, Node rhs, T arg) {
1251 handleStatic(node);
1252 handleNSMError(node); // operator on a method closure yields nSM
1253 handleNoSend(node); // setter is not invoked, don't count it.
1254 }
1255
1256 void visitStaticMethodSetterPostfix(Send node, FunctionElement getter,
1257 FunctionElement setter, IncDecOperator operator, T arg) {
1258 handleStatic(node);
1259 handleNSMError(node);
1260 handleNoSend(node);
1261 }
1262
1263 void visitStaticMethodSetterPrefix(Send node, FunctionElement getter,
1264 FunctionElement setter, IncDecOperator operator, T arg) {
1265 handleStatic(node);
1266 handleNSMError(node);
1267 handleNoSend(node);
1268 }
1269
1270 void visitStaticSetterGet(Send node, FunctionElement setter, T arg) {
1271 handleNSMError(node);
1272 }
1273
1274 void visitStaticSetterInvoke(Send node, FunctionElement setter,
1275 NodeList arguments, CallStructure callStructure, T arg) {
1276 handleNSMError(node);
1277 }
1278
1279 void visitSuperMethodCompound(Send node, FunctionElement method,
1280 AssignmentOperator operator, Node rhs, T arg) {
1281 handleSuper(node);
1282
1283 // An operator send on a method closure yields nSM
1284 handleNSMSuper(node, method.enclosingClass);
1285
1286 handleNoSend(node); // setter is not invoked, don't count it.
1287 }
1288
1289 void visitSuperMethodIncompatibleInvoke(Send node, MethodElement method,
1290 NodeList arguments, CallStructure callStructure, T arg) {
1291 handleNSMSuper(node, method.enclosingClass);
1292 }
1293
1294 void visitSuperMethodPostfix(
1295 Send node, FunctionElement method, IncDecOperator operator, T arg) {
1296 handleSuper(node);
1297 handleNSMSuper(node, method.enclosingClass);
1298 handleNoSend(node);
1299 }
1300
1301 void visitSuperMethodPrefix(
1302 Send node, FunctionElement method, IncDecOperator operator, T arg) {
1303 handleSuper(node);
1304 handleNSMSuper(node, method.enclosingClass);
1305 handleNoSend(node);
1306 }
1307
1308 void visitSuperMethodSet(Send node, MethodElement method, Node rhs, T arg) {
1309 handleNSMSuper(node, method.enclosingClass);
1310 }
1311
1312 void visitSuperMethodSetIfNull(
1313 Send node, MethodElement method, Node rhs, T arg) {
1314 handleNSMSuper(node, method.enclosingClass);
1315 }
1316
1317 void visitSuperSetterGet(Send node, FunctionElement setter, T arg) {
1318 handleNSMSuper(node, setter.enclosingClass);
1319 }
1320
1321 void visitSuperSetterInvoke(Send node, FunctionElement setter,
1322 NodeList arguments, CallStructure callStructure, T arg) {
1323 handleNSMSuper(node, setter.enclosingClass);
1324 }
1325
1326 void visitTopLevelFunctionIncompatibleInvoke(Send node,
1327 MethodElement function, NodeList arguments, CallStructure callStructure,
1328 T arg) {
1329 handleNSMError(node);
1330 }
1331
1332 void visitTopLevelFunctionSet(
1333 Send node, MethodElement function, Node rhs, T arg) {
1334 handleNSMError(node);
1335 }
1336
1337 void visitTopLevelGetterSet(
1338 SendSet node, FunctionElement getter, Node rhs, T arg) {
1339 handleNSMError(node);
1340 }
1341
1342 void visitTopLevelMethodCompound(Send node, FunctionElement method,
1343 AssignmentOperator operator, Node rhs, T arg) {
1344 handleStatic(node);
1345 handleNSMError(node); // operator on a method closure yields nSM
1346 handleNoSend(node); // setter is not invoked, don't count it.
1347 }
1348
1349 void visitTopLevelMethodPostfix(
1350 Send node, MethodElement method, IncDecOperator operator, T arg) {
1351 handleStatic(node);
1352 handleNSMError(node);
1353 handleNoSend(node);
1354 }
1355
1356 void visitTopLevelMethodPrefix(
1357 Send node, MethodElement method, IncDecOperator operator, T arg) {
1358 handleStatic(node);
1359 handleNSMError(node);
1360 handleNoSend(node);
1361 }
1362
1363 void visitTopLevelMethodSetterCompound(Send node, FunctionElement method,
1364 FunctionElement setter, AssignmentOperator operator, Node rhs, T arg) {
1365 handleStatic(node);
1366 handleNSMError(node); // operator on a method closure yields nSM
1367 handleNoSend(node); // setter is not invoked, don't count it.
1368 }
1369
1370 void visitTopLevelMethodSetterPostfix(Send node, FunctionElement method,
1371 FunctionElement setter, IncDecOperator operator, T arg) {
1372 handleStatic(node);
1373 handleNSMError(node);
1374 handleNoSend(node);
1375 }
1376
1377 void visitTopLevelMethodSetterPrefix(Send node, FunctionElement method,
1378 FunctionElement setter, IncDecOperator operator, T arg) {
1379 handleStatic(node);
1380 handleNSMError(node);
1381 handleNoSend(node);
1382 }
1383
1384 void visitTopLevelSetterGet(Send node, FunctionElement setter, T arg) {
1385 handleNSMError(node);
1386 }
1387
1388 void visitTopLevelSetterInvoke(Send node, FunctionElement setter,
1389 NodeList arguments, CallStructure callStructure, T arg) {
1390 handleNSMError(node);
1391 }
1392
1393 void visitTypeVariableTypeLiteralCompound(Send node,
1394 TypeVariableElement element, AssignmentOperator operator, Node rhs,
1395 T arg) {
1396 handleTypeVariable(node);
1397 handleNSMError(node); // operator on a method closure yields nSM
1398 handleNoSend(node); // setter is not invoked, don't count it.
1399 }
1400
1401 void visitTypeVariableTypeLiteralGet(
1402 Send node, TypeVariableElement element, T arg) {
1403 handleTypeVariable(node);
1404 }
1405
1406 void visitTypeVariableTypeLiteralInvoke(Send node,
1407 TypeVariableElement element, NodeList arguments,
1408 CallStructure callStructure, T arg) {
1409 handleNSMError(node);
1410 }
1411
1412 void visitTypeVariableTypeLiteralPostfix(
1413 Send node, TypeVariableElement element, IncDecOperator operator, T arg) {
1414 handleTypeVariable(node);
1415 handleNSMError(node);
1416 handleNoSend(node);
1417 }
1418
1419 void visitTypeVariableTypeLiteralPrefix(
1420 Send node, TypeVariableElement element, IncDecOperator operator, T arg) {
1421 handleTypeVariable(node);
1422 handleNSMError(node);
1423 handleNoSend(node);
1424 }
1425
1426 void visitTypeVariableTypeLiteralSet(
1427 SendSet node, TypeVariableElement element, Node rhs, T arg) {
1428 handleNSMError(node);
1429 }
1430
1431 void visitTypeVariableTypeLiteralSetIfNull(
1432 SendSet node, TypeVariableElement element, Node rhs, T arg) {
1433 handleTypeVariable(node);
1434 handleNSMError(node);
1435 }
1436
1437 void visitTypedefTypeLiteralCompound(Send node, ConstantExpression constant,
1438 AssignmentOperator operator, Node rhs, T arg) {
1439 handleTypeVariable(node);
1440 handleNSMError(node);
1441 handleNoSend(node);
1442 }
1443
1444 void visitTypedefTypeLiteralGet(
1445 Send node, ConstantExpression constant, T arg) {
1446 handleTypeVariable(node);
1447 }
1448
1449 void visitTypedefTypeLiteralInvoke(Send node, ConstantExpression constant,
1450 NodeList arguments, CallStructure callStructure, T arg) {
1451 handleNSMError(node);
1452 }
1453
1454 void visitTypedefTypeLiteralPostfix(
1455 Send node, ConstantExpression constant, IncDecOperator operator, T arg) {
1456 handleTypeVariable(node);
1457 handleNSMError(node);
1458 handleNoSend(node);
1459 }
1460
1461 void visitTypedefTypeLiteralPrefix(
1462 Send node, ConstantExpression constant, IncDecOperator operator, T arg) {
1463 handleTypeVariable(node);
1464 handleNSMError(node);
1465 handleNoSend(node);
1466 }
1467
1468 void visitTypedefTypeLiteralSet(
1469 SendSet node, ConstantExpression constant, Node rhs, T arg) {
1470 handleNSMError(node);
1471 }
1472
1473 void visitTypedefTypeLiteralSetIfNull(
1474 SendSet node, ConstantExpression constant, Node rhs, T arg) {
1475 handleStatic(node);
1476 handleNSMError(node);
1477 }
1478
1479 void visitUnresolvedClassConstructorInvoke(NewExpression node,
1480 Element element, DartType type, NodeList arguments, Selector selector,
1481 T arg) {
1482 handleNSMError(node);
1483 }
1484
1485 void visitUnresolvedCompound(Send node, Element element,
1486 AssignmentOperator operator, Node rhs, T arg) {
1487 handleNSMError(node);
1488 handleNoSend(node);
1489 handleNoSend(node);
1490 }
1491
1492 void visitUnresolvedConstructorInvoke(NewExpression node, Element constructor,
1493 DartType type, NodeList arguments, Selector selector, T arg) {
1494 handleNSMError(node);
1495 }
1496
1497 void visitUnresolvedGet(Send node, Element element, T arg) {
1498 handleNSMError(node);
1499 }
1500
1501 void visitUnresolvedInvoke(Send node, Element element, NodeList arguments,
1502 Selector selector, T arg) {
1503 handleNSMError(node);
1504 }
1505
1506 void visitUnresolvedPostfix(
1507 Send node, Element element, IncDecOperator operator, T arg) {
1508 handleNSMError(node);
1509 handleNoSend(node);
1510 handleNoSend(node);
1511 }
1512
1513 void visitUnresolvedPrefix(
1514 Send node, Element element, IncDecOperator operator, T arg) {
1515 handleNSMError(node);
1516 handleNoSend(node);
1517 handleNoSend(node);
1518 }
1519
1520 void visitUnresolvedRedirectingFactoryConstructorInvoke(NewExpression node,
1521 ConstructorElement constructor, InterfaceType type, NodeList arguments,
1522 CallStructure callStructure, T arg) {
1523 handleNSMError(node);
1524 }
1525
1526 void visitUnresolvedSet(Send node, Element element, Node rhs, T arg) {
1527 handleNSMError(node);
1528 }
1529
1530 void visitUnresolvedSetIfNull(Send node, Element element, Node rhs, T arg) {
1531 handleNSMError(node);
1532 handleNoSend(node);
1533 }
1534
1535 void visitUnresolvedStaticGetterCompound(Send node, Element element,
1536 MethodElement setter, AssignmentOperator operator, Node rhs, T arg) {
1537 handleNSMError(node);
1538 handleNoSend(node);
1539 handleNoSend(node);
1540 }
1541
1542 void visitUnresolvedStaticGetterPostfix(Send node, Element element,
1543 MethodElement setter, IncDecOperator operator, T arg) {
1544 handleNSMError(node);
1545 handleNoSend(node);
1546 handleNoSend(node);
1547 }
1548
1549 void visitUnresolvedStaticGetterPrefix(Send node, Element element,
1550 MethodElement setter, IncDecOperator operator, T arg) {
1551 handleNSMError(node);
1552 handleNoSend(node);
1553 handleNoSend(node);
1554 }
1555
1556 void visitUnresolvedStaticGetterSetIfNull(Send node, Element element,
1557 MethodElement setter, Node rhs, T arg) {
1558 handleNSMError(node);
1559 handleNoSend(node);
1560 }
1561
1562 void visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
1563 Element element, AssignmentOperator operator, Node rhs, T arg) {
1564 handleNSMError(node);
1565 handleNoSend(node);
1566 handleNoSend(node);
1567 }
1568
1569 void visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
1570 Element element, IncDecOperator operator, T arg) {
1571 handleNSMError(node);
1572 handleNoSend(node);
1573 handleNoSend(node);
1574 }
1575
1576 void visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
1577 Element element, IncDecOperator operator, T arg) {
1578 handleNSMError(node);
1579 handleNoSend(node);
1580 handleNoSend(node);
1581 }
1582
1583 void visitUnresolvedStaticSetterSetIfNull(Send node, MethodElement getter,
1584 Element element, Node rhs, T arg) {
1585 handleNSMError(node);
1586 handleNoSend(node);
1587 }
1588
1589 void visitUnresolvedSuperBinary(Send node, Element element,
1590 BinaryOperator operator, Node argument, T arg) {
1591 handleNSMSuper(node, element.enclosingClass);
1592 }
1593
1594 void visitUnresolvedSuperCompound(Send node, Element element,
1595 AssignmentOperator operator, Node rhs, T arg) {
1596 handleNSMSuper(node, element.enclosingClass);
1597 // TODO(sigmund): we should only count the next 2 if we know that the
1598 // superclass has a nSM method.
1599 handleOperator(node);
1600 handleNSMSuper(node, element.enclosingClass);
1601 }
1602
1603 void visitUnresolvedSuperCompoundIndexSet(Send node, Element element,
1604 Node index, AssignmentOperator operator, Node rhs, T arg) {
1605 handleNSMSuper(node, element.enclosingClass);
1606 handleNoSend(node);
1607 handleNSMSuper(node, element.enclosingClass);
1608 }
1609
1610 void visitUnresolvedSuperGet(Send node, Element element, T arg) {
1611 handleNSMSuper(node, element.enclosingClass);
1612 }
1613
1614 void visitUnresolvedSuperSetIfNull(
1615 Send node, Element element, Node rhs, T arg) {
1616 handleNSMSuper(node, element.enclosingClass);
1617 handleNoSend(node);
1618 }
1619
1620 void visitUnresolvedSuperGetterCompound(Send node, Element element,
1621 MethodElement setter, AssignmentOperator operator, Node rhs, T arg) {
1622 handleNSMSuper(node, element.enclosingClass);
1623 handleOperator(node);
1624 handleSuper(node);
1625 }
1626
1627 void visitUnresolvedSuperGetterCompoundIndexSet(Send node, Element element,
1628 MethodElement setter, Node index, AssignmentOperator operator, Node rhs,
1629 T arg) {
1630 handleNSMSuper(node, element.enclosingClass);
1631 handleOperator(node);
1632 handleSuper(node);
1633 }
1634
1635 void visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
1636 MethodElement setter, Node index, IncDecOperator operator, T arg) {
1637 handleNSMSuper(node, element.enclosingClass);
1638 handleOperator(node);
1639 handleSuper(node);
1640 }
1641
1642 void visitUnresolvedSuperGetterIndexPrefix(Send node, Element element,
1643 MethodElement setter, Node index, IncDecOperator operator, T arg) {
1644 handleNSMSuper(node, element.enclosingClass);
1645 handleOperator(node);
1646 handleSuper(node);
1647 }
1648
1649 void visitUnresolvedSuperGetterPostfix(Send node, Element element,
1650 MethodElement setter, IncDecOperator operator, T arg) {
1651 handleNSMSuper(node, element.enclosingClass);
1652 handleOperator(node);
1653 handleSuper(node);
1654 }
1655
1656 void visitUnresolvedSuperGetterPrefix(Send node, Element element,
1657 MethodElement setter, IncDecOperator operator, T arg) {
1658 handleNSMSuper(node, element.enclosingClass);
1659 handleOperator(node);
1660 handleSuper(node);
1661 }
1662
1663 void visitUnresolvedSuperGetterSetIfNull(Send node, Element element,
1664 MethodElement setter, Node rhs, T arg) {
1665 handleNSMSuper(node, element.enclosingClass);
1666 handleSuper(node);
1667 }
1668
1669 void visitUnresolvedSuperIndex(
1670 Send node, Element element, Node index, T arg) {
1671 handleNSMSuper(node, element.enclosingClass);
1672 }
1673
1674 void visitUnresolvedSuperIndexPostfix(
1675 Send node, Element element, Node index, IncDecOperator operator, T arg) {
1676 handleNSMSuper(node, element.enclosingClass);
1677 handleOperator(node);
1678 handleNSMSuper(node, element.enclosingClass);
1679 }
1680
1681 void visitUnresolvedSuperIndexPrefix(
1682 Send node, Element element, Node index, IncDecOperator operator, T arg) {
1683 handleNSMSuper(node, element.enclosingClass);
1684 handleOperator(node);
1685 handleNSMSuper(node, element.enclosingClass);
1686 }
1687
1688 void visitUnresolvedSuperIndexSet(
1689 Send node, Element element, Node index, Node rhs, T arg) {
1690 handleNSMSuper(node, element.enclosingClass);
1691 }
1692
1693 void visitUnresolvedSuperInvoke(Send node, Element element,
1694 NodeList arguments, Selector selector, T arg) {
1695 handleNSMSuper(node, element.enclosingClass);
1696 }
1697
1698 void visitUnresolvedSuperPostfix(
1699 Send node, Element element, IncDecOperator operator, T arg) {
1700 handleNSMSuper(node, element.enclosingClass);
1701 handleOperator(node);
1702 handleNSMSuper(node, element.enclosingClass);
1703 }
1704
1705 void visitUnresolvedSuperPrefix(
1706 Send node, Element element, IncDecOperator operator, T arg) {
1707 handleNSMSuper(node, element.enclosingClass);
1708 handleOperator(node);
1709 handleNSMSuper(node, element.enclosingClass);
1710 }
1711
1712 void visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
1713 Element element, AssignmentOperator operator, Node rhs, T arg) {
1714 handleSuper(node);
1715 handleOperator(node);
1716 handleNSMSuper(node, element.enclosingClass);
1717 }
1718
1719 void visitUnresolvedSuperSetterCompoundIndexSet(Send node,
1720 MethodElement getter, Element element, Node index,
1721 AssignmentOperator operator, Node rhs, T arg) {
1722 handleSuper(node);
1723 handleOperator(node);
1724 handleNSMSuper(node, element.enclosingClass);
1725 }
1726
1727 void visitUnresolvedSuperSetterIndexPostfix(Send node,
1728 MethodElement indexFunction, Element element, Node index,
1729 IncDecOperator operator, T arg) {
1730 handleSuper(node);
1731 handleOperator(node);
1732 handleNSMSuper(node, element.enclosingClass);
1733 }
1734
1735 void visitUnresolvedSuperSetterIndexPrefix(Send node,
1736 MethodElement indexFunction, Element element, Node index,
1737 IncDecOperator operator, T arg) {
1738 handleSuper(node);
1739 handleOperator(node);
1740 handleNSMSuper(node, element.enclosingClass);
1741 }
1742
1743 void visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
1744 Element element, IncDecOperator operator, T arg) {
1745 handleSuper(node);
1746 handleOperator(node);
1747 handleNSMSuper(node, element.enclosingClass);
1748 }
1749
1750 void visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
1751 Element element, IncDecOperator operator, T arg) {
1752 handleSuper(node);
1753 handleOperator(node);
1754 handleNSMSuper(node, element.enclosingClass);
1755 }
1756
1757 void visitUnresolvedSuperSetterSetIfNull(Send node, MethodElement getter,
1758 Element element, Node rhs, T arg) {
1759 handleSuper(node);
1760 handleNSMSuper(node, element.enclosingClass);
1761 }
1762
1763 void visitUnresolvedSuperUnary(
1764 Send node, UnaryOperator operator, Element element, T arg) {
1765 handleNSMSuper(node, element.enclosingClass);
1766 }
1767
1768 void visitUnresolvedTopLevelGetterCompound(Send node, Element element,
1769 MethodElement setter, AssignmentOperator operator, Node rhs, T arg) {
1770 handleNSMError(node);
1771 handleNoSend(node);
1772 handleNoSend(node);
1773 }
1774
1775 void visitUnresolvedTopLevelGetterPostfix(Send node, Element element,
1776 MethodElement setter, IncDecOperator operator, T arg) {
1777 handleNSMError(node);
1778 handleNoSend(node);
1779 handleNoSend(node);
1780 }
1781
1782 void visitUnresolvedTopLevelGetterPrefix(Send node, Element element,
1783 MethodElement setter, IncDecOperator operator, T arg) {
1784 handleNSMError(node);
1785 handleNoSend(node);
1786 handleNoSend(node);
1787 }
1788
1789 void visitUnresolvedTopLevelGetterSetIfNull(Send node, Element element,
1790 MethodElement setter, Node rhs, T arg) {
1791 handleNSMError(node);
1792 handleNoSend(node);
1793 }
1794
1795 void visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
1796 Element element, AssignmentOperator operator, Node rhs, T arg) {
1797 handleNSMError(node);
1798 handleNoSend(node);
1799 handleNoSend(node);
1800 }
1801
1802 void visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
1803 Element element, IncDecOperator operator, T arg) {
1804 handleNSMError(node);
1805 handleNoSend(node);
1806 handleNoSend(node);
1807 }
1808
1809 void visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
1810 Element element, IncDecOperator operator, T arg) {
1811 handleNSMError(node);
1812 handleNoSend(node);
1813 handleNoSend(node);
1814 }
1815
1816 void visitUnresolvedTopLevelSetterSetIfNull(Send node, MethodElement getter,
1817 Element element, Node rhs, T arg) {
1818 handleNSMError(node);
1819 handleNoSend(node);
1820 }
1821
1822 // Static
1823
1824 void visitConstantGet(Send node, ConstantExpression constant, T arg) {
1825 handleStatic(node);
1826 }
1827
1828 void visitConstantInvoke(Send node, ConstantExpression constant,
1829 NodeList arguments, CallStructure callStreucture, T arg) {
1830 handleStatic(node);
1831 }
1832
1833 void visitFactoryConstructorInvoke(NewExpression node,
1834 ConstructorElement constructor, InterfaceType type, NodeList arguments,
1835 CallStructure callStructure, T arg) {
1836 handleStatic(node);
1837 }
1838
1839 void visitStaticFieldGet(Send node, FieldElement field, T arg) {
1840 handleStatic(node);
1841 }
1842
1843 void visitStaticFieldSet(SendSet node, FieldElement field, Node rhs, T arg) {
1844 handleStatic(node);
1845 }
1846
1847 void visitStaticFieldSetIfNull(
1848 SendSet node, FieldElement field, Node rhs, T arg) {
1849 handleStatic(node);
1850 handleStatic(node);
1851 }
1852
1853 void visitStaticFunctionGet(Send node, MethodElement function, T arg) {
1854 handleStatic(node);
1855 }
1856
1857 void visitStaticFunctionInvoke(Send node, MethodElement function,
1858 NodeList arguments, CallStructure callStructure, T arg) {
1859 handleStatic(node);
1860 }
1861
1862 void visitStaticGetterGet(Send node, FunctionElement getter, T arg) {
1863 handleStatic(node);
1864 }
1865
1866 void visitStaticGetterSet(
1867 SendSet node, FunctionElement getter, Node rhs, T arg) {
1868 handleStatic(node);
1869 }
1870
1871 void visitStaticSetterSet(
1872 SendSet node, FunctionElement setter, Node rhs, T arg) {
1873 handleStatic(node);
1874 }
1875
1876 void visitStaticGetterSetterSetIfNull(
1877 Send node,
1878 FunctionElement getter,
1879 FunctionElement setter,
1880 Node rhs,
1881 T arg) {
1882 handleStatic(node);
1883 handleStatic(node);
1884 }
1885
1886 void visitStaticMethodSetterSetIfNull(
1887 Send node,
1888 MethodElement method,
1889 MethodElement setter,
1890 Node rhs,
1891 T arg) {
1892 handleStatic(node);
1893 handleStatic(node);
1894 }
1895
1896 void visitStaticMethodSetIfNull(
1897 Send node,
1898 FunctionElement method,
1899 Node rhs,
1900 T arg) {
1901 handleStatic(node);
1902 handleNSMError(node);
1903 }
1904
1905 void visitTopLevelFieldGet(Send node, FieldElement field, T arg) {
1906 handleStatic(node);
1907 }
1908
1909 void visitTopLevelFieldSet(
1910 SendSet node, FieldElement field, Node rhs, T arg) {
1911 handleStatic(node);
1912 }
1913
1914 void visitTopLevelFieldSetIfNull(
1915 SendSet node, FieldElement field, Node rhs, T arg) {
1916 handleStatic(node);
1917 handleStatic(node);
1918 }
1919
1920 void visitTopLevelFunctionGet(Send node, MethodElement function, T arg) {
1921 handleStatic(node);
1922 }
1923
1924 void visitTopLevelFunctionInvoke(Send node, MethodElement function,
1925 NodeList arguments, CallStructure callStructure, T arg) {
1926 handleStatic(node);
1927 }
1928
1929 void visitTopLevelGetterGet(Send node, FunctionElement getter, T arg) {
1930 handleStatic(node);
1931 }
1932
1933 void visitTopLevelSetterSet(
1934 SendSet node, FunctionElement setter, Node rhs, T arg) {
1935 handleStatic(node);
1936 }
1937
1938 // Virtual
1939
1940 void visitSuperCompoundIndexSet(SendSet node, MethodElement getter,
1941 MethodElement setter, Node index, AssignmentOperator operator, Node rhs,
1942 T arg) {
1943 handleSuper(node);
1944 handleOperator(node);
1945 handleSuper(node);
1946 }
1947
1948 void visitThisGet(Identifier node, T arg) {
1949 handleLocal(node); // TODO(sigmund): should we add a metric for "this"?
1950 }
1951
1952 void visitThisInvoke(
1953 Send node, NodeList arguments, CallStructure callStructure, T arg) {
1954 // TODO(sigmund): implement (treat like this.call())
1955 handleDynamic(node);
1956 }
1957
1958 void visitThisPropertyGet(Send node, Name name, T arg) {
1959 handleThisProperty(node, new Selector.getter(name));
1960 }
1961
1962 void visitThisPropertySet(SendSet node, Name name, Node rhs, T arg) {
1963 handleThisProperty(node, new Selector.setter(name));
1964 }
1965
1966 void visitThisPropertySetIfNull(Send node, Name name, Node rhs, T arg) {
1967 handleThisProperty(node, new Selector.getter(name));
1968 handleThisProperty(node, new Selector.setter(name));
1969 }
1970
1971 // Not count
1972
1973 void errorNonConstantConstructorInvoke(NewExpression node, Element element,
1974 DartType type, NodeList arguments, CallStructure callStructure, T arg) {
1975 handleNoSend(node);
1976 }
1977
1978 void errorUndefinedBinaryExpression(
1979 Send node, Node left, Operator operator, Node right, T arg) {
1980 handleNoSend(node);
1981 }
1982
1983 void errorUndefinedUnaryExpression(
1984 Send node, Operator operator, Node expression, T arg) {
1985 handleNoSend(node);
1986 }
1987
1988 void errorInvalidGet(
1989 Send node,
1990 ErroneousElement error,
1991 T arg) {
1992 handleNoSend(node);
1993 }
1994
1995 void errorInvalidInvoke(
1996 Send node,
1997 ErroneousElement error,
1998 NodeList arguments,
1999 Selector selector,
2000 T arg) {
2001 handleNoSend(node);
2002 }
2003
2004 void errorInvalidSet(
2005 Send node,
2006 ErroneousElement error,
2007 Node rhs,
2008 T arg) {
2009 handleNoSend(node);
2010 }
2011
2012 void errorInvalidSetIfNull(
2013 Send node, ErroneousElement error, Node rhs, T arg) {
2014 handleNoSend(node);
2015 handleNoSend(node);
2016 }
2017
2018
2019 void errorInvalidPrefix(
2020 Send node,
2021 ErroneousElement error,
2022 IncDecOperator operator,
2023 T arg) {
2024 handleNoSend(node);
2025 }
2026
2027 void errorInvalidPostfix(
2028 Send node,
2029 ErroneousElement error,
2030 IncDecOperator operator,
2031 T arg) {
2032 handleNoSend(node);
2033 }
2034
2035 void errorInvalidCompound(
2036 Send node,
2037 ErroneousElement error,
2038 AssignmentOperator operator,
2039 Node rhs,
2040 T arg) {
2041 handleNoSend(node);
2042 }
2043
2044 void errorInvalidUnary(
2045 Send node,
2046 UnaryOperator operator,
2047 ErroneousElement error,
2048 T arg) {
2049 handleNoSend(node);
2050 }
2051
2052 void errorInvalidEquals(
2053 Send node,
2054 ErroneousElement error,
2055 Node right,
2056 T arg) {
2057 handleNoSend(node);
2058 }
2059
2060 void errorInvalidNotEquals(
2061 Send node,
2062 ErroneousElement error,
2063 Node right,
2064 T arg) {
2065 handleNoSend(node);
2066 }
2067
2068 void errorInvalidBinary(
2069 Send node,
2070 ErroneousElement error,
2071 BinaryOperator operator,
2072 Node right,
2073 T arg) {
2074 handleNoSend(node);
2075 }
2076
2077 void errorInvalidIndex(
2078 Send node,
2079 ErroneousElement error,
2080 Node index,
2081 T arg) {
2082 handleNoSend(node);
2083 }
2084
2085 void errorInvalidIndexSet(
2086 Send node,
2087 ErroneousElement error,
2088 Node index,
2089 Node rhs,
2090 T arg) {
2091 handleNoSend(node);
2092 }
2093
2094 void errorInvalidCompoundIndexSet(
2095 Send node,
2096 ErroneousElement error,
2097 Node index,
2098 AssignmentOperator operator,
2099 Node rhs,
2100 T arg) {
2101 handleNoSend(node);
2102 handleNoSend(node);
2103 handleNoSend(node);
2104 }
2105
2106 void errorInvalidIndexPrefix(
2107 Send node,
2108 ErroneousElement error,
2109 Node index,
2110 IncDecOperator operator,
2111 T arg) {
2112 handleNoSend(node);
2113 handleNoSend(node);
2114 }
2115
2116 void errorInvalidIndexPostfix(
2117 Send node,
2118 ErroneousElement error,
2119 Node index,
2120 IncDecOperator operator,
2121 T arg) {
2122 handleNoSend(node);
2123 handleNoSend(node);
2124 }
2125
2126 void previsitDeferredAccess(
2127 Send node,
2128 PrefixElement prefix,
2129 T arg) {
2130 }
2131
2132
2133 void visitAs(Send node, Node expression, DartType type, T arg) {
2134 handleNoSend(node);
2135 }
2136
2137 void visitClassTypeLiteralCompound(Send node, ConstantExpression constant,
2138 AssignmentOperator operator, Node rhs, T arg) {
2139 handleStatic(node);
2140 handleNSMError(node);
2141 handleNoSend(node);
2142 }
2143
2144 void visitClassTypeLiteralGet(Send node, ConstantExpression constant, T arg) {
2145 handleStatic(node);
2146 }
2147
2148 void visitClassTypeLiteralInvoke(Send node, ConstantExpression constant,
2149 NodeList arguments, CallStructure callStructure, T arg) {
2150 handleNSMError(node);
2151 }
2152
2153 void visitClassTypeLiteralPostfix(
2154 Send node, ConstantExpression constant, IncDecOperator operator, T arg) {
2155 handleStatic(node);
2156 handleNSMError(node);
2157 handleNoSend(node);
2158 }
2159
2160 void visitClassTypeLiteralPrefix(
2161 Send node, ConstantExpression constant, IncDecOperator operator, T arg) {
2162 handleStatic(node);
2163 handleNSMError(node);
2164 handleNoSend(node);
2165 }
2166
2167 void visitClassTypeLiteralSet(
2168 SendSet node, ConstantExpression constant, Node rhs, T arg) {
2169 handleNSMError(node);
2170 }
2171
2172 void visitClassTypeLiteralSetIfNull(
2173 SendSet node, ConstantExpression constant, Node rhs, T arg) {
2174 handleStatic(node);
2175 handleNSMError(node);
2176 }
2177
2178 void visitDynamicTypeLiteralCompound(Send node, ConstantExpression constant,
2179 AssignmentOperator operator, Node rhs, T arg) {
2180 handleStatic(node);
2181 handleNSMError(node);
2182 handleNoSend(node);
2183 }
2184
2185 void visitDynamicTypeLiteralGet(
2186 Send node, ConstantExpression constant, T arg) {
2187 handleNSMError(node);
2188 }
2189
2190 void visitDynamicTypeLiteralInvoke(Send node, ConstantExpression constant,
2191 NodeList arguments, CallStructure callStructure, T arg) {
2192 handleNSMError(node);
2193 }
2194
2195 void visitDynamicTypeLiteralPostfix(
2196 Send node, ConstantExpression constant, IncDecOperator operator, T arg) {
2197 handleStatic(node);
2198 handleNSMError(node);
2199 handleNoSend(node);
2200 }
2201
2202 void visitDynamicTypeLiteralPrefix(
2203 Send node, ConstantExpression constant, IncDecOperator operator, T arg) {
2204 handleStatic(node);
2205 handleNSMError(node);
2206 handleNoSend(node);
2207 }
2208
2209 void visitDynamicTypeLiteralSet(
2210 SendSet node, ConstantExpression constant, Node rhs, T arg) {
2211 handleNSMError(node);
2212 }
2213
2214 void visitDynamicTypeLiteralSetIfNull(
2215 SendSet node, ConstantExpression constant, Node rhs, T arg) {
2216 handleStatic(node);
2217 handleNSMError(node);
2218 }
2219
2220 void visitIfNull(Send node, Node left, Node right, T arg) {
2221 handleNoSend(node);
2222 }
2223
2224 void visitIs(Send node, Node expression, DartType type, T arg) {
2225 handleNoSend(node);
2226 }
2227
2228 void visitIsNot(Send node, Node expression, DartType type, T arg) {
2229 handleNoSend(node);
2230 }
2231
2232 void visitLogicalAnd(Send node, Node left, Node right, T arg) {
2233 handleNoSend(node);
2234 }
2235
2236 void visitLogicalOr(Send node, Node left, Node right, T arg) {
2237 handleNoSend(node);
2238 }
2239
2240 void visitNot(Send node, Node expression, T arg) {
2241 handleNoSend(node);
2242 }
2243
2244 String last;
2245 _checkInvariant(node, String msg) {
2246 msg = '$msg ${recursiveDiagnosticString(measurements, Metric.send)}';
2247 if (!measurements.checkInvariant(Metric.send) ||
2248 !measurements.checkInvariant(Metric.monomorphicSend) ||
2249 !measurements.checkInvariant(Metric.polymorphicSend)) {
2250 compiler.reportErrorMessage(node,
2251 MessageKind.GENERIC, {'text': 'bad\n-- $msg\nlast:\n-- $last\n'});
2252 last = msg;
2253 } else {
2254 last = msg;
2255 }
2256 }
2257 }
2258
2259 /// Visitor that collects statistics for a single function.
2260 class _StatsTraversalVisitor<T> extends TraversalVisitor<dynamic, T>
2261 implements SemanticSendVisitor<dynamic, T> {
2262 final Compiler compiler;
2263 final _StatsVisitor statsVisitor;
2264 Measurements get measurements => statsVisitor.measurements;
2265 _StatsTraversalVisitor(
2266 Compiler compiler, TreeElements elements, Uri sourceUri)
2267 : compiler = compiler,
2268 statsVisitor = new _StatsVisitor(compiler, elements,
2269 // TODO(sigmund): accept a list of analyses, so we can compare them
2270 // together.
2271 true
2272 ? new TrustTypesAnalysisResult(elements, compiler.world)
2273 : new NaiveAnalysisResult(),
2274 sourceUri),
2275 super(elements);
2276
2277 void visitSend(Send node) {
2278 try {
2279 node.accept(statsVisitor);
2280 } catch (e, t) {
2281 compiler.reportErrorMessage(
2282 node, MessageKind.GENERIC, {'text': '$e\n$t'});
2283 }
2284 super.visitSend(node);
2285 }
2286
2287 void visitNewExpression(NewExpression node) {
2288 try {
2289 node.accept(statsVisitor);
2290 } catch (e, t) {
2291 compiler.reportErrorMessage(
2292 node, MessageKind.GENERIC, {'text': '$e\n$t'});
2293 }
2294 super.visitNewExpression(node);
2295 }
2296 }
2297
2298 /// Helper to visit elements recursively
2299 // TODO(sigmund): maybe generalize and move to elements/visitor.dart?
2300 abstract class RecursiveElementVisitor<R, A> extends ElementVisitor<R, A> {
2301
2302 @override
2303 R visitWarnOnUseElement(WarnOnUseElement e, A arg) =>
2304 e.wrappedElement.accept(this, arg);
2305
2306 R visitScopeContainerElement(ScopeContainerElement e, A arg) {
2307 e.forEachLocalMember((l) => l.accept(this, arg));
2308 return null;
2309 }
2310
2311 @override
2312 R visitCompilationUnitElement(CompilationUnitElement e, A arg) {
2313 e.forEachLocalMember((l) => l.accept(this, arg));
2314 return null;
2315 }
2316
2317 @override
2318 R visitLibraryElement(LibraryElement e, A arg) {
2319 e.implementation.compilationUnits.forEach((u) => u.accept(this, arg));
2320 return null;
2321 }
2322
2323 @override
2324 R visitVariableElement(VariableElement e, A arg) => null;
2325
2326 @override
2327 R visitParameterElement(ParameterElement e, A arg) => null;
2328
2329 @override
2330 R visitFormalElement(FormalElement e, A arg) => null;
2331
2332 @override
2333 R visitFieldElement(FieldElement e, A arg) => null;
2334
2335 @override
2336 R visitFieldParameterElement(InitializingFormalElement e, A arg) => null;
2337
2338 @override
2339 R visitAbstractFieldElement(AbstractFieldElement e, A arg) => null;
2340
2341 @override
2342 R visitFunctionElement(FunctionElement e, A arg) => null;
2343
2344 @override
2345 R visitConstructorElement(ConstructorElement e, A arg) {
2346 return visitFunctionElement(e, arg);
2347 }
2348
2349 @override
2350 R visitConstructorBodyElement(ConstructorBodyElement e, A arg) {
2351 return visitFunctionElement(e.constructor, arg);
2352 }
2353
2354 @override
2355 R visitClassElement(ClassElement e, A arg) {
2356 return visitScopeContainerElement(e, arg);
2357 }
2358
2359 @override
2360 R visitEnumClassElement(EnumClassElement e, A arg) {
2361 return visitClassElement(e, arg);
2362 }
2363
2364 @override
2365 R visitBoxFieldElement(BoxFieldElement e, A arg) => null;
2366
2367 @override
2368 R visitClosureClassElement(ClosureClassElement e, A arg) {
2369 return visitClassElement(e, arg);
2370 }
2371
2372 @override
2373 R visitClosureFieldElement(ClosureFieldElement e, A arg) {
2374 return visitVariableElement(e, arg);
2375 }
2376 }
2377
2378 // TODO(sigmund): get rid of debug messages.
2379 _debug(String message) {
2380 print('debug: $message');
2381 }
OLDNEW
« no previous file with comments | « pkg/compiler/lib/src/stats/analysis_result.dart ('k') | pkg/compiler/lib/src/stats/naive_analysis_result.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698