// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file | |
// for details. All rights reserved. Use of this source code is governed by a | |
// BSD-style license that can be found in the LICENSE file. | |
part of dart2js.semantics_visitor_test; | |
class SemanticSendTestVisitor extends SemanticTestVisitor { | |
SemanticSendTestVisitor(TreeElements elements) : super(elements); | |
@override | |
visitAs( | |
Send node, | |
Node expression, | |
DartType type, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_AS, | |
expression: expression, type: type)); | |
apply(expression, arg); | |
} | |
@override | |
visitAssert( | |
Send node, | |
Node expression, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_ASSERT, expression: expression)); | |
super.visitAssert(node, expression, arg); | |
} | |
@override | |
errorInvalidAssert( | |
Send node, | |
NodeList arguments, | |
arg) { | |
visits.add(new Visit(VisitKind.ERROR_INVALID_ASSERT, arguments: arguments)); | |
super.errorInvalidAssert(node, arguments, arg); | |
} | |
@override | |
visitBinary( | |
Send node, | |
Node left, | |
BinaryOperator operator, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_BINARY, | |
left: left, operator: operator, right: right)); | |
super.visitBinary(node, left, operator, right, arg); | |
} | |
@override | |
errorUndefinedBinaryExpression( | |
Send node, | |
Node left, | |
Operator operator, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.ERROR_UNDEFINED_BINARY_EXPRESSION, | |
left: left, operator: operator, right: right)); | |
super.errorUndefinedBinaryExpression(node, left, operator, right, arg); | |
} | |
@override | |
visitIndex( | |
Send node, | |
Node receiver, | |
Node index, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_INDEX, | |
receiver: receiver, index: index)); | |
apply(receiver, arg); | |
apply(index, arg); | |
} | |
@override | |
visitClassTypeLiteralGet( | |
Send node, | |
ConstantExpression constant, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_GET, | |
constant: constant.getText())); | |
} | |
@override | |
visitClassTypeLiteralInvoke( | |
Send node, | |
ConstantExpression constant, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_INVOKE, | |
constant: constant.getText(), arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitClassTypeLiteralSet( | |
SendSet node, | |
ConstantExpression constant, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_INVOKE, | |
constant: constant.getText(), rhs: rhs)); | |
super.visitClassTypeLiteralSet(node, constant, rhs, arg); | |
} | |
@override | |
visitNotEquals( | |
Send node, | |
Node left, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_NOT_EQUALS, | |
left: left, right: right)); | |
apply(left, arg); | |
apply(right, arg); | |
} | |
@override | |
visitDynamicPropertyPrefix( | |
Send node, | |
Node receiver, | |
IncDecOperator operator, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_PREFIX, | |
receiver: receiver, operator: operator, | |
getter: getterSelector, setter: setterSelector)); | |
apply(receiver, arg); | |
} | |
@override | |
visitDynamicPropertyPostfix( | |
Send node, | |
Node receiver, | |
IncDecOperator operator, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_POSTFIX, | |
receiver: receiver, operator: operator, | |
getter: getterSelector, setter: setterSelector)); | |
apply(receiver, arg); | |
} | |
@override | |
visitDynamicPropertyGet( | |
Send node, | |
Node receiver, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_GET, | |
receiver: receiver, name: selector.name)); | |
apply(receiver, arg); | |
} | |
@override | |
visitDynamicPropertyInvoke( | |
Send node, | |
Node receiver, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_INVOKE, | |
receiver: receiver, name: selector.name, arguments: arguments)); | |
apply(receiver, arg); | |
apply(arguments, arg); | |
} | |
@override | |
visitDynamicPropertySet( | |
SendSet node, | |
Node receiver, | |
Selector selector, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_SET, | |
receiver: receiver, name: selector.name, rhs: rhs)); | |
super.visitDynamicPropertySet(node, receiver, selector, rhs, arg); | |
} | |
@override | |
visitDynamicTypeLiteralGet( | |
Send node, | |
ConstantExpression constant, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_GET, | |
constant: constant.getText())); | |
} | |
@override | |
visitDynamicTypeLiteralInvoke( | |
Send node, | |
ConstantExpression constant, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_INVOKE, | |
constant: constant.getText(), arguments: arguments)); | |
} | |
@override | |
visitDynamicTypeLiteralSet( | |
Send node, | |
ConstantExpression constant, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_SET, | |
rhs: rhs)); | |
super.visitDynamicTypeLiteralSet(node, constant, rhs, arg); | |
} | |
@override | |
visitExpressionInvoke( | |
Send node, | |
Node expression, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_EXPRESSION_INVOKE, | |
receiver: expression, arguments: arguments)); | |
} | |
@override | |
visitIs( | |
Send node, | |
Node expression, | |
DartType type, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IS, | |
expression: expression, type: type)); | |
apply(expression, arg); | |
} | |
@override | |
visitIsNot( | |
Send node, | |
Node expression, | |
DartType type, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IS_NOT, | |
expression: expression, type: type)); | |
apply(expression, arg); | |
} | |
@override | |
visitLogicalAnd( | |
Send node, | |
Node left, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOGICAL_AND, | |
left: left, right: right)); | |
apply(left, arg); | |
apply(right, arg); | |
} | |
@override | |
visitLogicalOr( | |
Send node, | |
Node left, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOGICAL_OR, | |
left: left, right: right)); | |
apply(left, arg); | |
apply(right, arg); | |
} | |
@override | |
visitLocalFunctionGet( | |
Send node, | |
LocalFunctionElement function, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_GET, | |
element: function)); | |
} | |
@override | |
visitLocalFunctionSet( | |
SendSet node, | |
LocalFunctionElement function, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_SET, | |
element: function, rhs: rhs)); | |
super.visitLocalFunctionSet(node, function, rhs, arg); | |
} | |
@override | |
visitLocalFunctionInvoke( | |
Send node, | |
LocalFunctionElement function, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_INVOKE, | |
element: function, arguments: arguments, selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitLocalVariableGet( | |
Send node, | |
LocalVariableElement variable, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_GET, | |
element: variable)); | |
} | |
@override | |
visitLocalVariableInvoke( | |
Send node, | |
LocalVariableElement variable, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_INVOKE, | |
element: variable, arguments: arguments, selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitLocalVariableSet( | |
SendSet node, | |
LocalVariableElement variable, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_SET, | |
element: variable, rhs: rhs)); | |
super.visitLocalVariableSet(node, variable, rhs, arg); | |
} | |
@override | |
visitFinalLocalVariableSet( | |
SendSet node, | |
LocalVariableElement variable, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_SET, | |
element: variable, rhs: rhs)); | |
super.visitFinalLocalVariableSet(node, variable, rhs, arg); | |
} | |
@override | |
visitParameterGet( | |
Send node, | |
ParameterElement parameter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_PARAMETER_GET, element: parameter)); | |
} | |
@override | |
visitParameterInvoke( | |
Send node, | |
ParameterElement parameter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_PARAMETER_INVOKE, | |
element: parameter, arguments: arguments, selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitParameterSet( | |
SendSet node, | |
ParameterElement parameter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_PARAMETER_SET, | |
element: parameter, rhs: rhs)); | |
super.visitParameterSet(node, parameter, rhs, arg); | |
} | |
@override | |
visitFinalParameterSet( | |
SendSet node, | |
ParameterElement parameter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_SET, | |
element: parameter, rhs: rhs)); | |
super.visitFinalParameterSet(node, parameter, rhs, arg); | |
} | |
@override | |
visitStaticFieldGet( | |
Send node, | |
FieldElement field, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_GET, element: field)); | |
} | |
@override | |
visitStaticFieldInvoke( | |
Send node, | |
FieldElement field, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_INVOKE, | |
element: field, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitStaticFieldSet( | |
SendSet node, | |
FieldElement field, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_SET, | |
element: field, rhs: rhs)); | |
super.visitStaticFieldSet(node, field, rhs, arg); | |
} | |
@override | |
visitFinalStaticFieldSet( | |
SendSet node, | |
FieldElement field, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_STATIC_FIELD_SET, | |
element: field, rhs: rhs)); | |
super.visitFinalStaticFieldSet(node, field, rhs, arg); | |
} | |
@override | |
visitStaticFunctionGet( | |
Send node, | |
MethodElement function, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FUNCTION_GET, | |
element: function)); | |
} | |
@override | |
visitStaticFunctionSet( | |
SendSet node, | |
MethodElement function, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FUNCTION_SET, | |
element: function, rhs: rhs)); | |
super.visitStaticFunctionSet(node, function, rhs, arg); | |
} | |
@override | |
visitStaticFunctionInvoke( | |
Send node, | |
MethodElement function, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FUNCTION_INVOKE, | |
element: function, arguments: arguments)); | |
super.visitStaticFunctionInvoke( | |
node, function, arguments, callStructure, arg); | |
} | |
@override | |
visitStaticFunctionIncompatibleInvoke( | |
Send node, | |
MethodElement function, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FUNCTION_INCOMPATIBLE_INVOKE, | |
element: function, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitStaticGetterGet( | |
Send node, | |
FunctionElement getter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_GET, | |
element: getter)); | |
super.visitStaticGetterGet(node, getter, arg); | |
} | |
@override | |
visitStaticGetterSet( | |
SendSet node, | |
MethodElement getter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_SET, | |
element: getter, rhs: rhs)); | |
super.visitStaticGetterSet(node, getter, rhs, arg); | |
} | |
@override | |
visitStaticGetterInvoke( | |
Send node, | |
FunctionElement getter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_INVOKE, | |
element: getter, arguments: arguments)); | |
super.visitStaticGetterInvoke(node, getter, arguments, callStructure, arg); | |
} | |
@override | |
visitStaticSetterInvoke( | |
Send node, | |
FunctionElement setter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_SETTER_INVOKE, | |
element: setter, arguments: arguments)); | |
super.visitStaticSetterInvoke(node, setter, arguments, callStructure, arg); | |
} | |
@override | |
visitStaticSetterGet( | |
Send node, | |
FunctionElement getter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_SETTER_GET, | |
element: getter)); | |
super.visitStaticSetterGet(node, getter, arg); | |
} | |
@override | |
visitStaticSetterSet( | |
SendSet node, | |
FunctionElement setter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_SETTER_SET, | |
element: setter, rhs: rhs)); | |
super.visitStaticSetterSet(node, setter, rhs, arg); | |
} | |
@override | |
visitSuperBinary( | |
Send node, | |
FunctionElement function, | |
BinaryOperator operator, | |
Node argument, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_BINARY, | |
element: function, operator: operator, right: argument)); | |
apply(argument, arg); | |
} | |
@override | |
visitUnresolvedSuperBinary( | |
Send node, | |
Element element, | |
BinaryOperator operator, | |
Node argument, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_BINARY, | |
operator: operator, right: argument)); | |
apply(argument, arg); | |
} | |
@override | |
visitSuperIndex( | |
Send node, | |
FunctionElement function, | |
Node index, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX, | |
element: function, index: index)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedSuperIndex( | |
Send node, | |
Element element, | |
Node index, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX, | |
index: index)); | |
apply(index, arg); | |
} | |
@override | |
visitSuperNotEquals( | |
Send node, | |
FunctionElement function, | |
Node argument, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_NOT_EQUALS, | |
element: function, right: argument)); | |
apply(argument, arg); | |
} | |
@override | |
visitThisGet(Identifier node, arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_GET)); | |
} | |
@override | |
visitThisInvoke( | |
Send node, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_INVOKE, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitThisPropertyGet( | |
Send node, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_GET, | |
name: selector.name)); | |
} | |
@override | |
visitThisPropertyInvoke( | |
Send node, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_INVOKE, | |
name: selector.name, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitThisPropertySet( | |
SendSet node, | |
Selector selector, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_SET, | |
name: selector.name, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitTopLevelFieldGet( | |
Send node, | |
FieldElement field, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_GET, element: field)); | |
} | |
@override | |
visitTopLevelFieldInvoke( | |
Send node, | |
FieldElement field, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_INVOKE, | |
element: field, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitTopLevelFieldSet( | |
SendSet node, | |
FieldElement field, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_SET, | |
element: field, rhs: rhs)); | |
super.visitTopLevelFieldSet(node, field, rhs, arg); | |
} | |
@override | |
visitFinalTopLevelFieldSet( | |
SendSet node, | |
FieldElement field, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_TOP_LEVEL_FIELD_SET, | |
element: field, rhs: rhs)); | |
super.visitFinalTopLevelFieldSet(node, field, rhs, arg); | |
} | |
@override | |
visitTopLevelFunctionGet( | |
Send node, | |
MethodElement function, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_GET, | |
element: function)); | |
} | |
@override | |
visitTopLevelFunctionSet( | |
SendSet node, | |
MethodElement function, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_SET, | |
element: function, rhs: rhs)); | |
super.visitTopLevelFunctionSet(node, function, rhs, arg); | |
} | |
@override | |
visitTopLevelFunctionInvoke( | |
Send node, | |
MethodElement function, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_INVOKE, | |
element: function, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitTopLevelFunctionIncompatibleInvoke( | |
Send node, | |
MethodElement function, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_INCOMPATIBLE_INVOKE, | |
element: function, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitTopLevelGetterGet( | |
Send node, | |
FunctionElement getter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_GET, | |
element: getter)); | |
super.visitTopLevelGetterGet(node, getter, arg); | |
} | |
@override | |
visitTopLevelSetterGet( | |
Send node, | |
FunctionElement setter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_SETTER_GET, | |
element: setter)); | |
super.visitTopLevelSetterGet(node, setter, arg); | |
} | |
@override | |
visitTopLevelGetterInvoke( | |
Send node, | |
FunctionElement getter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_INVOKE, | |
element: getter, arguments: arguments)); | |
super.visitTopLevelGetterInvoke( | |
node, getter, arguments, callStructure, arg); | |
} | |
@override | |
visitTopLevelSetterInvoke( | |
Send node, | |
FunctionElement setter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_SETTER_INVOKE, | |
element: setter, arguments: arguments)); | |
super.visitTopLevelSetterInvoke( | |
node, setter, arguments, callStructure, arg); | |
} | |
@override | |
visitTopLevelGetterSet( | |
SendSet node, | |
FunctionElement getter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_SET, | |
element: getter, rhs: rhs)); | |
super.visitTopLevelGetterSet(node, getter, rhs, arg); | |
} | |
@override | |
visitTopLevelSetterSet( | |
SendSet node, | |
FunctionElement setter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_SETTER_SET, | |
element: setter, rhs: rhs)); | |
super.visitTopLevelSetterSet(node, setter, rhs, arg); | |
} | |
@override | |
visitTypeVariableTypeLiteralGet( | |
Send node, | |
TypeVariableElement element, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_GET, | |
element: element)); | |
} | |
@override | |
visitTypeVariableTypeLiteralInvoke( | |
Send node, | |
TypeVariableElement element, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_INVOKE, | |
element: element, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitTypeVariableTypeLiteralSet( | |
SendSet node, | |
TypeVariableElement element, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_SET, | |
element: element, rhs: rhs)); | |
super.visitTypeVariableTypeLiteralSet(node, element, rhs, arg); | |
} | |
@override | |
visitTypedefTypeLiteralGet( | |
Send node, | |
ConstantExpression constant, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_GET, | |
constant: constant.getText())); | |
} | |
@override | |
visitTypedefTypeLiteralInvoke( | |
Send node, | |
ConstantExpression constant, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_INVOKE, | |
constant: constant.getText(), arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitTypedefTypeLiteralSet( | |
SendSet node, | |
ConstantExpression constant, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_SET, | |
constant: constant.getText(), rhs: rhs)); | |
super.visitTypedefTypeLiteralSet(node, constant, rhs, arg); | |
} | |
@override | |
visitUnary( | |
Send node, | |
UnaryOperator operator, | |
Node expression, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNARY, | |
expression: expression, operator: operator)); | |
super.visitUnary(node, operator, expression, arg); | |
} | |
@override | |
errorUndefinedUnaryExpression( | |
Send node, | |
Operator operator, | |
Node expression, | |
arg) { | |
visits.add(new Visit(VisitKind.ERROR_UNDEFINED_UNARY_EXPRESSION, | |
expression: expression, operator: operator)); | |
super.errorUndefinedUnaryExpression(node, operator, expression, arg); | |
} | |
@override | |
visitNot( | |
Send node, | |
Node expression, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_NOT, expression: expression)); | |
apply(expression, arg); | |
} | |
@override | |
visitSuperFieldGet( | |
Send node, | |
FieldElement field, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_GET, element: field)); | |
} | |
@override | |
visitUnresolvedSuperGet( | |
Send node, | |
Element element, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GET)); | |
} | |
@override | |
visitSuperFieldInvoke( | |
Send node, | |
FieldElement field, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_INVOKE, | |
element: field, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitUnresolvedSuperInvoke( | |
Send node, | |
Element element, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INVOKE, | |
arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitSuperFieldSet( | |
SendSet node, | |
FieldElement field, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_SET, | |
element: field, rhs: rhs)); | |
super.visitSuperFieldSet(node, field, rhs, arg); | |
} | |
@override | |
visitFinalSuperFieldSet( | |
SendSet node, | |
FieldElement field, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_SUPER_FIELD_SET, | |
element: field, rhs: rhs)); | |
super.visitFinalSuperFieldSet(node, field, rhs, arg); | |
} | |
@override | |
visitSuperMethodGet( | |
Send node, | |
MethodElement method, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_GET, element: method)); | |
} | |
@override | |
visitSuperMethodSet( | |
SendSet node, | |
MethodElement method, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SET, | |
element: method, rhs: rhs)); | |
super.visitSuperMethodSet(node, method, rhs, arg); | |
} | |
@override | |
visitSuperMethodInvoke( | |
Send node, | |
MethodElement method, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_INVOKE, | |
element: method, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitSuperMethodIncompatibleInvoke( | |
Send node, | |
MethodElement method, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_INCOMPATIBLE_INVOKE, | |
element: method, arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitSuperGetterGet( | |
Send node, | |
FunctionElement getter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_GET, element: getter)); | |
super.visitSuperGetterGet(node, getter, arg); | |
} | |
@override | |
visitSuperSetterGet( | |
Send node, | |
FunctionElement setter, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_SETTER_GET, element: setter)); | |
super.visitSuperSetterGet(node, setter, arg); | |
} | |
@override | |
visitSuperGetterInvoke( | |
Send node, | |
FunctionElement getter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_INVOKE, | |
element: getter, arguments: arguments)); | |
super.visitSuperGetterInvoke(node, getter, arguments, callStructure, arg); | |
} | |
@override | |
visitSuperSetterInvoke( | |
Send node, | |
FunctionElement setter, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_SETTER_INVOKE, | |
element: setter, arguments: arguments)); | |
super.visitSuperSetterInvoke(node, setter, arguments, callStructure, arg); | |
} | |
@override | |
visitSuperGetterSet( | |
SendSet node, | |
FunctionElement getter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_SET, | |
element: getter, rhs: rhs)); | |
super.visitSuperGetterSet(node, getter, rhs, arg); | |
} | |
@override | |
visitSuperSetterSet( | |
SendSet node, | |
FunctionElement setter, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_SETTER_SET, | |
element: setter, rhs: rhs)); | |
super.visitSuperSetterSet(node, setter, rhs, arg); | |
} | |
@override | |
visitSuperUnary( | |
Send node, | |
UnaryOperator operator, | |
FunctionElement function, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_UNARY, | |
element: function, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperUnary( | |
Send node, | |
UnaryOperator operator, | |
Element element, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_UNARY, | |
operator: operator)); | |
} | |
@override | |
visitEquals( | |
Send node, | |
Node left, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_EQUALS, left: left, right: right)); | |
apply(left, arg); | |
apply(right, arg); | |
} | |
@override | |
visitSuperEquals( | |
Send node, | |
FunctionElement function, | |
Node argument, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_EQUALS, | |
element: function, right: argument)); | |
apply(argument, arg); | |
} | |
@override | |
visitIndexSet( | |
Send node, | |
Node receiver, | |
Node index, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_INDEX_SET, | |
receiver: receiver, index: index, rhs: rhs)); | |
apply(receiver, arg); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperIndexSet( | |
Send node, | |
FunctionElement function, | |
Node index, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX_SET, | |
element: function, index: index, rhs: rhs)); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitDynamicPropertyCompound( | |
Send node, | |
Node receiver, | |
AssignmentOperator operator, | |
Node rhs, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_COMPOUND, | |
receiver: receiver, operator: operator, rhs: rhs, | |
getter: getterSelector, setter: setterSelector)); | |
apply(receiver, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitFinalLocalVariableCompound( | |
Send node, | |
LocalVariableElement variable, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_COMPOUND, | |
element: variable, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitFinalLocalVariablePrefix( | |
Send node, | |
LocalVariableElement variable, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_PREFIX, | |
element: variable, operator: operator)); | |
} | |
@override | |
visitFinalLocalVariablePostfix( | |
Send node, | |
LocalVariableElement variable, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_POSTFIX, | |
element: variable, operator: operator)); | |
} | |
@override | |
visitFinalParameterCompound( | |
Send node, | |
ParameterElement parameter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_COMPOUND, | |
element: parameter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitFinalParameterPrefix( | |
Send node, | |
ParameterElement parameter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_PREFIX, | |
element: parameter, operator: operator)); | |
} | |
@override | |
visitFinalParameterPostfix( | |
Send node, | |
ParameterElement parameter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_POSTFIX, | |
element: parameter, operator: operator)); | |
} | |
@override | |
visitFinalStaticFieldCompound( | |
Send node, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_COMPOUND, | |
element: field, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitFinalStaticFieldPostfix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_POSTFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitFinalStaticFieldPrefix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_PREFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitFinalSuperFieldCompound( | |
Send node, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_COMPOUND, | |
element: field, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitFinalTopLevelFieldCompound( | |
Send node, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_COMPOUND, | |
element: field, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitFinalTopLevelFieldPostfix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_POSTFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitFinalTopLevelFieldPrefix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_PREFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitLocalFunctionCompound( | |
Send node, | |
LocalFunctionElement function, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_COMPOUND, | |
element: function, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitLocalVariableCompound( | |
Send node, | |
LocalVariableElement variable, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_COMPOUND, | |
element: variable, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitParameterCompound( | |
Send node, | |
ParameterElement parameter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_PARAMETER_COMPOUND, | |
element: parameter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitStaticFieldCompound( | |
Send node, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_COMPOUND, | |
element: field, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitStaticGetterSetterCompound( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_SETTER_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: getter, setter: setter)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperFieldCompound( | |
Send node, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_COMPOUND, | |
element: field, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperGetterSetterCompound( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_SETTER_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: getter, setter: setter)); | |
apply(rhs, arg); | |
} | |
@override | |
visitThisPropertyCompound( | |
Send node, | |
AssignmentOperator operator, | |
Node rhs, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: getterSelector, setter: setterSelector)); | |
apply(rhs, arg); | |
} | |
@override | |
visitTopLevelFieldCompound( | |
Send node, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_COMPOUND, | |
element: field, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitTopLevelGetterSetterCompound( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_SETTER_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: getter, setter: setter)); | |
apply(rhs, arg); | |
} | |
@override | |
visitStaticMethodSetterCompound( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: method, setter: setter)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperFieldSetterCompound( | |
Send node, | |
FieldElement field, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: field, setter: setter)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperGetterFieldCompound( | |
Send node, | |
FunctionElement getter, | |
FieldElement field, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_FIELD_COMPOUND, | |
operator: operator, rhs: rhs, | |
getter: getter, setter: field)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperMethodSetterCompound( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_COMPOUND, | |
getter: method, setter: setter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperMethodCompound( | |
Send node, | |
FunctionElement method, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_COMPOUND, | |
element: method, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperMethodPrefix( | |
Send node, | |
FunctionElement method, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_PREFIX, | |
element: method, operator: operator)); | |
} | |
@override | |
visitSuperMethodPostfix( | |
Send node, | |
FunctionElement method, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_POSTFIX, | |
element: method, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperCompound( | |
Send node, | |
Element element, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_COMPOUND, | |
operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperPrefix( | |
Send node, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_PREFIX, | |
operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperPostfix( | |
Send node, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_POSTFIX, | |
operator: operator)); | |
} | |
@override | |
visitTopLevelMethodSetterCompound( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_COMPOUND, | |
getter: method, setter: setter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitCompoundIndexSet( | |
Send node, | |
Node receiver, | |
Node index, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_COMPOUND_INDEX_SET, | |
receiver: receiver, index: index, rhs: rhs, operator: operator)); | |
apply(receiver, arg); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperCompoundIndexSet( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
Node index, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_COMPOUND_INDEX_SET, | |
getter: getter, setter: setter, | |
index: index, rhs: rhs, operator: operator)); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitClassTypeLiteralCompound( | |
Send node, | |
ConstantExpression constant, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_COMPOUND, | |
constant: constant.getText(), operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitDynamicTypeLiteralCompound( | |
Send node, | |
ConstantExpression constant, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND, | |
constant: constant.getText(), operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitTypeVariableTypeLiteralCompound( | |
Send node, | |
TypeVariableElement element, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND, | |
element: element, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitTypedefTypeLiteralCompound( | |
Send node, | |
ConstantExpression constant, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND, | |
constant: constant.getText(), operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitLocalFunctionPrefix( | |
Send node, | |
LocalFunctionElement function, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_PREFIX, | |
element: function, operator: operator)); | |
} | |
@override | |
visitClassTypeLiteralPrefix( | |
Send node, | |
ConstantExpression constant, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_PREFIX, | |
constant: constant.getText(), operator: operator)); | |
} | |
@override | |
visitDynamicTypeLiteralPrefix( | |
Send node, | |
ConstantExpression constant, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_PREFIX, | |
constant: constant.getText(), operator: operator)); | |
} | |
@override | |
visitLocalVariablePrefix( | |
Send node, | |
LocalVariableElement variable, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_PREFIX, | |
element: variable, operator: operator)); | |
} | |
@override | |
visitParameterPrefix( | |
Send node, | |
ParameterElement parameter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_PARAMETER_PREFIX, | |
element: parameter, operator: operator)); | |
} | |
@override | |
visitStaticFieldPrefix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_PREFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitStaticGetterSetterPrefix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_SETTER_PREFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitStaticMethodSetterPrefix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_PREFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitSuperFieldFieldCompound( | |
Send node, | |
FieldElement readField, | |
FieldElement writtenField, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_COMPOUND, | |
getter: readField, setter: writtenField, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitSuperFieldFieldPrefix( | |
Send node, | |
FieldElement readField, | |
FieldElement writtenField, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_PREFIX, | |
getter: readField, setter: writtenField, operator: operator)); | |
} | |
@override | |
visitSuperFieldPrefix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_PREFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitFinalSuperFieldPrefix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_PREFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitSuperFieldSetterPrefix( | |
Send node, | |
FieldElement field, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_PREFIX, | |
getter: field, setter: setter, operator: operator)); | |
} | |
@override | |
visitSuperGetterFieldPrefix( | |
Send node, | |
FunctionElement getter, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_FIELD_PREFIX, | |
getter: getter, setter: field, operator: operator)); | |
} | |
@override | |
visitSuperGetterSetterPrefix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_SETTER_PREFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitSuperMethodSetterPrefix( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_PREFIX, | |
getter: method, setter: setter, operator: operator)); | |
} | |
@override | |
visitThisPropertyPrefix( | |
Send node, | |
IncDecOperator operator, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_PREFIX, | |
operator: operator, | |
getter: getterSelector, setter: setterSelector)); | |
} | |
@override | |
visitTopLevelFieldPrefix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_PREFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitTopLevelGetterSetterPrefix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_SETTER_PREFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitTopLevelMethodSetterPrefix( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_PREFIX, | |
getter: method, setter: setter, operator: operator)); | |
} | |
@override | |
visitTypeVariableTypeLiteralPrefix( | |
Send node, | |
TypeVariableElement element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX, | |
element: element, operator: operator)); | |
} | |
@override | |
visitTypedefTypeLiteralPrefix( | |
Send node, | |
ConstantExpression constant, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_PREFIX, | |
constant: constant.getText(), operator: operator)); | |
} | |
@override | |
visitLocalFunctionPostfix( | |
Send node, | |
LocalFunctionElement function, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_POSTFIX, | |
element: function, operator: operator)); | |
} | |
@override | |
visitClassTypeLiteralPostfix( | |
Send node, | |
ConstantExpression constant, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_POSTFIX, | |
constant: constant.getText(), operator: operator)); | |
} | |
@override | |
visitDynamicTypeLiteralPostfix( | |
Send node, | |
ConstantExpression constant, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX, | |
constant: constant.getText(), operator: operator)); | |
} | |
@override | |
visitLocalVariablePostfix( | |
Send node, | |
LocalVariableElement variable, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_POSTFIX, | |
element: variable, operator: operator)); | |
} | |
@override | |
visitParameterPostfix( | |
Send node, | |
ParameterElement parameter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_PARAMETER_POSTFIX, | |
element: parameter, operator: operator)); | |
} | |
@override | |
visitStaticFieldPostfix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_POSTFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitStaticGetterSetterPostfix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_SETTER_POSTFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitStaticMethodSetterPostfix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_POSTFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitSuperFieldFieldPostfix( | |
Send node, | |
FieldElement readField, | |
FieldElement writtenField, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_POSTFIX, | |
getter: readField, setter: writtenField, operator: operator)); | |
} | |
@override | |
visitSuperFieldPostfix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_POSTFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitFinalSuperFieldPostfix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_POSTFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitSuperFieldSetterPostfix( | |
Send node, | |
FieldElement field, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_POSTFIX, | |
getter: field, setter: setter, operator: operator)); | |
} | |
@override | |
visitSuperGetterFieldPostfix( | |
Send node, | |
FunctionElement getter, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_FIELD_POSTFIX, | |
getter: getter, setter: field, operator: operator)); | |
} | |
@override | |
visitSuperGetterSetterPostfix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_GETTER_SETTER_POSTFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitSuperMethodSetterPostfix( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_POSTFIX, | |
getter: method, setter: setter, operator: operator)); | |
} | |
@override | |
visitThisPropertyPostfix( | |
Send node, | |
IncDecOperator operator, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_POSTFIX, | |
operator: operator, | |
getter: getterSelector, setter: setterSelector)); | |
} | |
@override | |
visitTopLevelFieldPostfix( | |
Send node, | |
FieldElement field, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_POSTFIX, | |
element: field, operator: operator)); | |
} | |
@override | |
visitTopLevelGetterSetterPostfix( | |
Send node, | |
FunctionElement getter, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_SETTER_POSTFIX, | |
getter: getter, setter: setter, operator: operator)); | |
} | |
@override | |
visitTopLevelMethodSetterPostfix( | |
Send node, | |
FunctionElement method, | |
FunctionElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_POSTFIX, | |
getter: method, setter: setter, operator: operator)); | |
} | |
@override | |
visitTypeVariableTypeLiteralPostfix( | |
Send node, | |
TypeVariableElement element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX, | |
element: element, operator: operator)); | |
} | |
@override | |
visitTypedefTypeLiteralPostfix( | |
Send node, | |
ConstantExpression constant, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX, | |
constant: constant.getText(), operator: operator)); | |
} | |
@override | |
visitUnresolvedCompound( | |
Send node, | |
ErroneousElement element, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_COMPOUND, | |
operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedGet( | |
Send node, | |
Element element, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_GET, name: element.name)); | |
} | |
@override | |
visitUnresolvedSet( | |
Send node, | |
Element element, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SET, | |
name: element.name, rhs: rhs)); | |
super.visitUnresolvedSet(node, element, rhs, arg); | |
} | |
@override | |
visitUnresolvedInvoke( | |
Send node, | |
Element element, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_INVOKE, | |
name: element.name, arguments: arguments)); | |
super.visitUnresolvedInvoke(node, element, arguments, selector, arg); | |
} | |
@override | |
visitUnresolvedPostfix( | |
Send node, | |
ErroneousElement element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_POSTFIX, operator: operator)); | |
} | |
@override | |
visitUnresolvedPrefix( | |
Send node, | |
ErroneousElement element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_PREFIX, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperCompoundIndexSet( | |
Send node, | |
Element element, | |
Node index, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_SUPER_COMPOUND_INDEX_SET, | |
index: index, operator: operator, rhs: rhs)); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperGetterCompoundIndexSet( | |
Send node, | |
Element element, | |
MethodElement setter, | |
Node index, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET, | |
setter: setter, index: index, operator: operator, rhs: rhs)); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperSetterCompoundIndexSet( | |
Send node, | |
MethodElement getter, | |
Element element, | |
Node index, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND_INDEX_SET, | |
getter: getter, index: index, operator: operator, rhs: rhs)); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperIndexSet( | |
Send node, | |
ErroneousElement element, | |
Node index, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_SET, | |
index: index, rhs: rhs)); | |
apply(index, arg); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperIndexPostfix( | |
Send node, | |
Element element, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_POSTFIX, | |
index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedSuperGetterIndexPostfix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX, | |
setter: setter, index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedSuperSetterIndexPostfix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_POSTFIX, | |
getter: getter, index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedSuperIndexPrefix( | |
Send node, | |
Element element, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_PREFIX, | |
index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedSuperGetterIndexPrefix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX, | |
setter: setter, index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedSuperSetterIndexPrefix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_PREFIX, | |
getter: getter, index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitIndexPostfix( | |
Send node, | |
Node receiver, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_INDEX_POSTFIX, | |
receiver: receiver, index: index, operator: operator)); | |
apply(receiver, arg); | |
apply(index, arg); | |
} | |
@override | |
visitIndexPrefix( | |
Send node, | |
Node receiver, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_INDEX_PREFIX, | |
receiver: receiver, index: index, operator: operator)); | |
apply(receiver, arg); | |
apply(index, arg); | |
} | |
@override | |
visitSuperIndexPostfix( | |
Send node, | |
FunctionElement indexFunction, | |
FunctionElement indexSetFunction, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX_POSTFIX, | |
getter: indexFunction, setter: indexSetFunction, | |
index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitSuperIndexPrefix( | |
Send node, | |
FunctionElement indexFunction, | |
FunctionElement indexSetFunction, | |
Node index, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX_PREFIX, | |
getter: indexFunction, setter: indexSetFunction, | |
index: index, operator: operator)); | |
apply(index, arg); | |
} | |
@override | |
visitUnresolvedClassConstructorInvoke( | |
NewExpression node, | |
Element constructor, | |
DartType type, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
// TODO(johnniwinther): Test [type] when it is not `dynamic`. | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_CLASS_CONSTRUCTOR_INVOKE, | |
arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitUnresolvedConstructorInvoke( | |
NewExpression node, | |
Element constructor, | |
DartType type, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
// TODO(johnniwinther): Test [type] when it is not `dynamic`. | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_CONSTRUCTOR_INVOKE, | |
arguments: arguments)); | |
apply(arguments, arg); | |
} | |
@override | |
visitConstConstructorInvoke( | |
NewExpression node, | |
ConstructedConstantExpression constant, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CONST_CONSTRUCTOR_INVOKE, | |
constant: constant.getText())); | |
super.visitConstConstructorInvoke(node, constant, arg); | |
} | |
@override | |
visitBoolFromEnvironmentConstructorInvoke( | |
NewExpression node, | |
BoolFromEnvironmentConstantExpression constant, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_BOOL_FROM_ENVIRONMENT_CONSTRUCTOR_INVOKE, | |
constant: constant.getText())); | |
super.visitBoolFromEnvironmentConstructorInvoke(node, constant, arg); | |
} | |
@override | |
visitIntFromEnvironmentConstructorInvoke( | |
NewExpression node, | |
IntFromEnvironmentConstantExpression constant, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_INT_FROM_ENVIRONMENT_CONSTRUCTOR_INVOKE, | |
constant: constant.getText())); | |
super.visitIntFromEnvironmentConstructorInvoke(node, constant, arg); | |
} | |
@override | |
visitStringFromEnvironmentConstructorInvoke( | |
NewExpression node, | |
StringFromEnvironmentConstantExpression constant, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_STRING_FROM_ENVIRONMENT_CONSTRUCTOR_INVOKE, | |
constant: constant.getText())); | |
super.visitStringFromEnvironmentConstructorInvoke(node, constant, arg); | |
} | |
@override | |
errorNonConstantConstructorInvoke( | |
NewExpression node, | |
Element element, | |
DartType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE, | |
element: element, type: type, | |
arguments: arguments, selector: callStructure)); | |
super.errorNonConstantConstructorInvoke( | |
node, element, type, arguments, callStructure, arg); | |
} | |
@override | |
visitConstructorIncompatibleInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CONSTRUCTOR_INCOMPATIBLE_INVOKE, | |
element: constructor, type: type, | |
arguments: arguments, selector: callStructure)); | |
super.visitConstructorIncompatibleInvoke( | |
node, constructor, type, arguments, callStructure, arg); | |
} | |
@override | |
visitFactoryConstructorInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_FACTORY_CONSTRUCTOR_INVOKE, | |
element: constructor, | |
type: type, | |
arguments: arguments, | |
selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitGenerativeConstructorInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_GENERATIVE_CONSTRUCTOR_INVOKE, | |
element: constructor, | |
type: type, | |
arguments: arguments, | |
selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitRedirectingFactoryConstructorInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
ConstructorElement effectiveTarget, | |
InterfaceType effectiveTargetType, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE, | |
element: constructor, | |
type: type, | |
target: effectiveTarget, | |
targetType: effectiveTargetType, | |
arguments: arguments, | |
selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitRedirectingGenerativeConstructorInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_REDIRECTING_GENERATIVE_CONSTRUCTOR_INVOKE, | |
element: constructor, | |
type: type, | |
arguments: arguments, | |
selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitAbstractClassConstructorInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_ABSTRACT_CLASS_CONSTRUCTOR_INVOKE, | |
element: constructor, | |
type: type, | |
arguments: arguments, | |
selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitUnresolvedRedirectingFactoryConstructorInvoke( | |
NewExpression node, | |
ConstructorElement constructor, | |
InterfaceType type, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit( | |
VisitKind.VISIT_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE, | |
element: constructor, | |
type: type, | |
arguments: arguments, | |
selector: callStructure)); | |
apply(arguments, arg); | |
} | |
@override | |
visitUnresolvedStaticGetterCompound( | |
Send node, | |
Element element, | |
MethodElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_COMPOUND, | |
setter: setter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedTopLevelGetterCompound( | |
Send node, | |
Element element, | |
MethodElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_COMPOUND, | |
setter: setter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedStaticSetterCompound( | |
Send node, | |
MethodElement getter, | |
Element element, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_COMPOUND, | |
getter: getter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedTopLevelSetterCompound( | |
Send node, | |
MethodElement getter, | |
Element element, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_COMPOUND, | |
getter: getter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitStaticMethodCompound( | |
Send node, | |
MethodElement method, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_COMPOUND, | |
element: method, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitTopLevelMethodCompound( | |
Send node, | |
MethodElement method, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_COMPOUND, | |
element: method, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedStaticGetterPrefix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_PREFIX, | |
setter: setter, operator: operator)); | |
} | |
@override | |
visitUnresolvedTopLevelGetterPrefix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_PREFIX, | |
setter: setter, operator: operator)); | |
} | |
@override | |
visitUnresolvedStaticSetterPrefix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_PREFIX, | |
getter: getter, operator: operator)); | |
} | |
@override | |
visitUnresolvedTopLevelSetterPrefix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_PREFIX, | |
getter: getter, operator: operator)); | |
} | |
@override | |
visitStaticMethodPrefix( | |
Send node, | |
MethodElement method, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_PREFIX, | |
element: method, operator: operator)); | |
} | |
@override | |
visitTopLevelMethodPrefix( | |
Send node, | |
MethodElement method, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_PREFIX, | |
element: method, operator: operator)); | |
} | |
@override | |
visitUnresolvedStaticGetterPostfix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_POSTFIX, | |
setter: setter, operator: operator)); | |
} | |
@override | |
visitUnresolvedTopLevelGetterPostfix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_POSTFIX, | |
setter: setter, operator: operator)); | |
} | |
@override | |
visitUnresolvedStaticSetterPostfix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_POSTFIX, | |
getter: getter, operator: operator)); | |
} | |
@override | |
visitUnresolvedTopLevelSetterPostfix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_POSTFIX, | |
getter: getter, operator: operator)); | |
} | |
@override | |
visitStaticMethodPostfix( | |
Send node, | |
MethodElement method, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_POSTFIX, | |
element: method, operator: operator)); | |
} | |
@override | |
visitTopLevelMethodPostfix( | |
Send node, | |
MethodElement method, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_POSTFIX, | |
element: method, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperGetterCompound( | |
Send node, Element element, | |
MethodElement setter, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND, | |
setter: setter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperGetterPostfix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_POSTFIX, | |
setter: setter, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperGetterPrefix( | |
Send node, | |
Element element, | |
MethodElement setter, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_PREFIX, | |
setter: setter, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperSetterCompound( | |
Send node, MethodElement getter, | |
Element element, | |
AssignmentOperator operator, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND, | |
getter: getter, operator: operator, rhs: rhs)); | |
apply(rhs, arg); | |
} | |
@override | |
visitUnresolvedSuperSetterPostfix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_POSTFIX, | |
getter: getter, operator: operator)); | |
} | |
@override | |
visitUnresolvedSuperSetterPrefix( | |
Send node, | |
MethodElement getter, | |
Element element, | |
IncDecOperator operator, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_PREFIX, | |
getter: getter, operator: operator)); | |
} | |
@override | |
visitIfNotNullDynamicPropertyGet( | |
Send node, | |
Node receiver, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_GET, | |
receiver: receiver, name: selector.name)); | |
super.visitIfNotNullDynamicPropertyGet(node, receiver, selector, arg); | |
} | |
@override | |
visitIfNotNullDynamicPropertySet( | |
Send node, | |
Node receiver, | |
Selector selector, | |
Node rhs, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_SET, | |
receiver: receiver, name: selector.name, rhs: rhs)); | |
super.visitIfNotNullDynamicPropertySet(node, receiver, selector, rhs, arg); | |
} | |
@override | |
visitIfNotNullDynamicPropertyInvoke( | |
Send node, | |
Node receiver, | |
NodeList arguments, | |
Selector selector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_INVOKE, | |
receiver: receiver, selector: selector, arguments: arguments)); | |
super.visitIfNotNullDynamicPropertyInvoke( | |
node, receiver, arguments, selector, arg); | |
} | |
@override | |
visitIfNotNullDynamicPropertyPrefix( | |
Send node, | |
Node receiver, | |
IncDecOperator operator, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_PREFIX, | |
receiver: receiver, operator: operator, | |
getter: getterSelector, setter: setterSelector)); | |
super.visitIfNotNullDynamicPropertyPrefix( | |
node, receiver, operator, getterSelector, setterSelector, arg); | |
} | |
@override | |
visitIfNotNullDynamicPropertyPostfix( | |
Send node, | |
Node receiver, | |
IncDecOperator operator, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_POSTFIX, | |
receiver: receiver, operator: operator, | |
getter: getterSelector, setter: setterSelector)); | |
super.visitIfNotNullDynamicPropertyPostfix( | |
node, receiver, operator, getterSelector, setterSelector, arg); | |
} | |
@override | |
visitIfNotNullDynamicPropertyCompound( | |
Send node, | |
Node receiver, | |
AssignmentOperator operator, | |
Node rhs, | |
Selector getterSelector, | |
Selector setterSelector, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NOT_NULL_DYNAMIC_PROPERTY_COMPOUND, | |
receiver: receiver, operator: operator, rhs: rhs, | |
getter: getterSelector, setter: setterSelector)); | |
super.visitIfNotNullDynamicPropertyCompound( | |
node, receiver, operator, rhs, getterSelector, setterSelector, arg); | |
} | |
@override | |
visitIfNull( | |
Send node, | |
Node left, | |
Node right, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_IF_NULL, left: left, right: right)); | |
super.visitIfNull(node, left, right, arg); | |
} | |
@override | |
visitConstantGet( | |
Send node, | |
ConstantExpression constant, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CONSTANT_GET, | |
constant: constant.getText())); | |
super.visitConstantGet(node, constant, arg); | |
} | |
@override | |
visitConstantInvoke( | |
Send node, | |
ConstantExpression constant, | |
NodeList arguments, | |
CallStructure callStructure, | |
arg) { | |
visits.add(new Visit(VisitKind.VISIT_CONSTANT_INVOKE, | |
constant: constant.getText())); | |
super.visitConstantInvoke(node, constant, arguments, callStructure, arg); | |
} | |
} |