blob: 05e5c1b24c17a5bb6794c1894bb67877397bddd6 [file] [log] [blame]
// Copyright (c) 2014, 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.
import 'dart:async';
import 'package:analysis_server/src/protocol_server.dart' hide Element;
import 'package:analysis_server/src/services/correction/status.dart';
import 'package:analysis_server/src/services/correction/strings.dart';
import 'package:analysis_server/src/services/correction/util.dart';
import 'package:analysis_server/src/services/refactoring/refactoring.dart';
import 'package:analysis_server/src/services/refactoring/refactoring_internal.dart';
import 'package:analysis_server/src/services/search/hierarchy.dart';
import 'package:analysis_server/src/services/search/search_engine.dart';
import 'package:analyzer/dart/analysis/results.dart';
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/src/dart/ast/utilities.dart';
import 'package:analyzer/src/dart/element/ast_provider.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer_plugin/utilities/range_factory.dart';
/**
* Returns the [SourceRange] to find conflicting locals in.
*/
SourceRange _getLocalsConflictingRange(AstNode node) {
// maybe Block
Block block = node.getAncestor((node) => node is Block);
if (block != null) {
return range.startEnd(node, block);
}
// maybe whole executable
AstNode executableNode = getEnclosingExecutableNode(node);
if (executableNode != null) {
return range.node(executableNode);
}
// not a part of a declaration with locals
return SourceRange.EMPTY;
}
/**
* Returns the source which should replace given invocation with given
* arguments.
*/
String _getMethodSourceForInvocation(
RefactoringStatus status,
_SourcePart part,
CorrectionUtils utils,
AstNode contextNode,
Expression targetExpression,
List<Expression> arguments) {
// prepare edits to replace parameters with arguments
List<SourceEdit> edits = <SourceEdit>[];
part._parameters.forEach(
(ParameterElement parameter, List<_ParameterOccurrence> occurrences) {
// prepare argument
Expression argument = null;
for (Expression arg in arguments) {
if (arg.staticParameterElement == parameter) {
argument = arg;
break;
}
}
if (argument is NamedExpression) {
argument = (argument as NamedExpression).expression;
}
// prepare argument properties
int argumentPrecedence;
String argumentSource;
if (argument != null) {
argumentPrecedence = getExpressionPrecedence(argument);
argumentSource = utils.getNodeText(argument);
} else {
// report about a missing required parameter
if (parameter.isNotOptional) {
status.addError('No argument for the parameter "${parameter.name}".',
newLocation_fromNode(contextNode));
return;
}
// an optional parameter
argumentPrecedence = -1000;
argumentSource = parameter.defaultValueCode;
if (argumentSource == null) {
argumentSource = 'null';
}
}
// replace all occurrences of this parameter
for (_ParameterOccurrence occurrence in occurrences) {
SourceRange range = occurrence.range;
// prepare argument source to apply at this occurrence
String occurrenceArgumentSource;
if (argumentPrecedence < occurrence.parentPrecedence) {
occurrenceArgumentSource = "($argumentSource)";
} else {
occurrenceArgumentSource = argumentSource;
}
// do replace
edits.add(newSourceEdit_range(range, occurrenceArgumentSource));
}
});
// replace static field "qualifier" with invocation target
part._implicitClassNameOffsets.forEach((String className, List<int> offsets) {
for (int offset in offsets) {
// edits.add(newSourceEdit_range(range, className + '.'));
edits.add(new SourceEdit(offset, 0, className + '.'));
}
});
// replace "this" references with invocation target
if (targetExpression != null) {
String targetSource = utils.getNodeText(targetExpression);
// explicit "this" references
for (int offset in part._explicitThisOffsets) {
edits.add(new SourceEdit(offset, 4, targetSource));
}
// implicit "this" references
targetSource += '.';
for (int offset in part._implicitThisOffsets) {
edits.add(new SourceEdit(offset, 0, targetSource));
}
}
// prepare edits to replace conflicting variables
Set<String> conflictingNames = _getNamesConflictingAt(contextNode);
part._variables.forEach((VariableElement variable, List<SourceRange> ranges) {
String originalName = variable.displayName;
// prepare unique name
String uniqueName;
{
uniqueName = originalName;
int uniqueIndex = 2;
while (conflictingNames.contains(uniqueName)) {
uniqueName = originalName + uniqueIndex.toString();
uniqueIndex++;
}
}
// update references, if name was change
if (uniqueName != originalName) {
for (SourceRange range in ranges) {
edits.add(newSourceEdit_range(range, uniqueName));
}
}
});
// prepare source with applied arguments
edits.sort((SourceEdit a, SourceEdit b) => b.offset - a.offset);
return SourceEdit.applySequence(part._source, edits);
}
/**
* Returns the names which will shadow or will be shadowed by any declaration
* at [node].
*/
Set<String> _getNamesConflictingAt(AstNode node) {
Set<String> result = new Set<String>();
// local variables and functions
{
SourceRange localsRange = _getLocalsConflictingRange(node);
AstNode enclosingExecutable = getEnclosingExecutableNode(node);
List<LocalElement> elements = getDefinedLocalElements(enclosingExecutable);
for (LocalElement element in elements) {
SourceRange elementRange = element.visibleRange;
if (elementRange != null && elementRange.intersects(localsRange)) {
result.add(element.displayName);
}
}
}
// fields
{
ClassElement enclosingClassElement = getEnclosingClassElement(node);
if (enclosingClassElement != null) {
Set<ClassElement> elements = new Set<ClassElement>();
elements.add(enclosingClassElement);
elements.addAll(getSuperClasses(enclosingClassElement));
for (ClassElement classElement in elements) {
List<Element> classMembers = getChildren(classElement);
for (Element classMemberElement in classMembers) {
result.add(classMemberElement.displayName);
}
}
}
}
// done
return result;
}
/**
* [InlineMethodRefactoring] implementation.
*/
class InlineMethodRefactoringImpl extends RefactoringImpl
implements InlineMethodRefactoring {
final SearchEngine searchEngine;
final AstProvider astProvider;
final ResolveResult resolveResult;
final int offset;
ResolvedUnitCache _unitCache;
CorrectionUtils utils;
SourceChange change;
bool isDeclaration = false;
bool deleteSource = false;
bool inlineAll = true;
ExecutableElement _methodElement;
bool _isAccessor;
CompilationUnit _methodUnit;
CorrectionUtils _methodUtils;
AstNode _methodNode;
FormalParameterList _methodParameters;
FunctionBody _methodBody;
Expression _methodExpression;
_SourcePart _methodExpressionPart;
_SourcePart _methodStatementsPart;
final List<_ReferenceProcessor> _referenceProcessors = [];
final Set<FunctionBody> _alreadyMadeAsync = new Set<FunctionBody>();
InlineMethodRefactoringImpl(
this.searchEngine, this.astProvider, this.resolveResult, this.offset) {
_unitCache = new ResolvedUnitCache(astProvider, resolveResult.unit);
utils =
new CorrectionUtils(resolveResult.unit, buffer: resolveResult.content);
}
@override
String get className {
if (_methodElement == null) {
return null;
}
Element classElement = _methodElement.enclosingElement;
if (classElement is ClassElement) {
return classElement.displayName;
}
return null;
}
@override
String get methodName {
if (_methodElement == null) {
return null;
}
return _methodElement.displayName;
}
@override
String get refactoringName {
if (_methodElement is MethodElement) {
return "Inline Method";
} else {
return "Inline Function";
}
}
@override
Future<RefactoringStatus> checkFinalConditions() {
change = new SourceChange(refactoringName);
RefactoringStatus result = new RefactoringStatus();
// check for compatibility of "deleteSource" and "inlineAll"
if (deleteSource && !inlineAll) {
result.addError('All references must be inlined to remove the source.');
}
// prepare changes
for (_ReferenceProcessor processor in _referenceProcessors) {
processor._process(result);
}
// delete method
if (deleteSource && inlineAll) {
SourceRange methodRange = range.node(_methodNode);
SourceRange linesRange =
_methodUtils.getLinesRange(methodRange, skipLeadingEmptyLines: true);
doSourceChange_addElementEdit(
change, _methodElement, newSourceEdit_range(linesRange, ''));
}
// done
return new Future.value(result);
}
@override
Future<RefactoringStatus> checkInitialConditions() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
RefactoringStatus result = new RefactoringStatus();
// prepare method information
result.addStatus(await _prepareMethod());
if (result.hasFatalError) {
return new Future<RefactoringStatus>.value(result);
}
// maybe operator
if (_methodElement.isOperator) {
result = new RefactoringStatus.fatal('Cannot inline operator.');
return new Future<RefactoringStatus>.value(result);
}
// maybe [a]sync*
if (_methodElement.isGenerator) {
result = new RefactoringStatus.fatal('Cannot inline a generator.');
return new Future<RefactoringStatus>.value(result);
}
// analyze method body
result.addStatus(_prepareMethodParts());
// process references
List<SearchMatch> references =
await searchEngine.searchReferences(_methodElement);
_referenceProcessors.clear();
for (SearchMatch reference in references) {
_ReferenceProcessor processor = new _ReferenceProcessor(this, reference);
await processor.init();
_referenceProcessors.add(processor);
}
return result;
}
@override
Future<SourceChange> createChange() {
return new Future.value(change);
}
Future<FunctionDeclaration> _computeFunctionDeclaration() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
CompilationUnit unit = await _unitCache.getUnit(_methodElement);
return new NodeLocator(_methodElement.nameOffset)
.searchWithin(unit)
.getAncestor((n) => n is FunctionDeclaration) as FunctionDeclaration;
}
Future<MethodDeclaration> _computeMethodDeclaration() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
CompilationUnit unit = await _unitCache.getUnit(_methodElement);
return new NodeLocator(_methodElement.nameOffset)
.searchWithin(unit)
.getAncestor((n) => n is MethodDeclaration) as MethodDeclaration;
}
_SourcePart _createSourcePart(SourceRange range) {
String source = _methodUtils.getRangeText(range);
String prefix = getLinePrefix(source);
_SourcePart result = new _SourcePart(range.offset, source, prefix);
// remember parameters and variables occurrences
_methodUnit.accept(new _VariablesVisitor(_methodElement, range, result));
// done
return result;
}
/**
* Initializes [_methodElement] and related fields.
*/
Future<RefactoringStatus> _prepareMethod() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
_methodElement = null;
_methodParameters = null;
_methodBody = null;
deleteSource = false;
inlineAll = false;
// prepare for failure
RefactoringStatus fatalStatus = new RefactoringStatus.fatal(
'Method declaration or reference must be selected to activate this refactoring.');
// prepare selected SimpleIdentifier
AstNode node = new NodeLocator(offset).searchWithin(resolveResult.unit);
if (node is! SimpleIdentifier) {
return fatalStatus;
}
SimpleIdentifier identifier = node as SimpleIdentifier;
// prepare selected ExecutableElement
Element element = identifier.staticElement;
if (element is! ExecutableElement) {
return fatalStatus;
}
if (element.isSynthetic) {
return fatalStatus;
}
_methodElement = element as ExecutableElement;
_isAccessor = element is PropertyAccessorElement;
_methodUnit = await _unitCache.getUnit(element);
_methodUtils = new CorrectionUtils(_methodUnit);
// class member
bool isClassMember = element.enclosingElement is ClassElement;
if (element is MethodElement || _isAccessor && isClassMember) {
MethodDeclaration methodDeclaration = await _computeMethodDeclaration();
_methodNode = methodDeclaration;
_methodParameters = methodDeclaration.parameters;
_methodBody = methodDeclaration.body;
// prepare mode
isDeclaration = node == methodDeclaration.name;
deleteSource = isDeclaration;
inlineAll = deleteSource;
return new RefactoringStatus();
}
// unit member
bool isUnitMember = element.enclosingElement is CompilationUnitElement;
if (element is FunctionElement || _isAccessor && isUnitMember) {
FunctionDeclaration functionDeclaration =
await _computeFunctionDeclaration();
_methodNode = functionDeclaration;
_methodParameters = functionDeclaration.functionExpression.parameters;
_methodBody = functionDeclaration.functionExpression.body;
// prepare mode
isDeclaration = node == functionDeclaration.name;
deleteSource = isDeclaration;
inlineAll = deleteSource;
return new RefactoringStatus();
}
// OK
return fatalStatus;
}
/**
* Analyze [_methodBody] to fill [_methodExpressionPart] and
* [_methodStatementsPart].
*/
RefactoringStatus _prepareMethodParts() {
RefactoringStatus result = new RefactoringStatus();
if (_methodBody is ExpressionFunctionBody) {
ExpressionFunctionBody body = _methodBody as ExpressionFunctionBody;
_methodExpression = body.expression;
SourceRange methodExpressionRange = range.node(_methodExpression);
_methodExpressionPart = _createSourcePart(methodExpressionRange);
} else if (_methodBody is BlockFunctionBody) {
Block body = (_methodBody as BlockFunctionBody).block;
List<Statement> statements = body.statements;
if (statements.length >= 1) {
Statement lastStatement = statements[statements.length - 1];
// "return" statement requires special handling
if (lastStatement is ReturnStatement) {
_methodExpression = lastStatement.expression;
SourceRange methodExpressionRange = range.node(_methodExpression);
_methodExpressionPart = _createSourcePart(methodExpressionRange);
// exclude "return" statement from statements
statements = statements.sublist(0, statements.length - 1);
}
// if there are statements, process them
if (!statements.isEmpty) {
SourceRange statementsRange =
_methodUtils.getLinesRangeStatements(statements);
_methodStatementsPart = _createSourcePart(statementsRange);
}
}
// check if more than one return
body.accept(new _ReturnsValidatorVisitor(result));
} else {
return new RefactoringStatus.fatal('Cannot inline method without body.');
}
return result;
}
}
class _ParameterOccurrence {
final int parentPrecedence;
final SourceRange range;
_ParameterOccurrence(this.parentPrecedence, this.range);
}
/**
* Processor for single [SearchMatch] reference to [methodElement].
*/
class _ReferenceProcessor {
final InlineMethodRefactoringImpl ref;
final SearchMatch reference;
Element refElement;
CorrectionUtils _refUtils;
SimpleIdentifier _node;
SourceRange _refLineRange;
String _refPrefix;
_ReferenceProcessor(this.ref, this.reference);
Future<void> init() async {
// TODO(brianwilkerson) Determine whether this await is necessary.
await null;
refElement = reference.element;
// prepare CorrectionUtils
CompilationUnit refUnit = await ref._unitCache.getUnit(refElement);
_refUtils = new CorrectionUtils(refUnit);
// prepare node and environment
_node = _refUtils.findNode(reference.sourceRange.offset);
Statement refStatement = _node.getAncestor((node) => node is Statement);
if (refStatement != null) {
_refLineRange = _refUtils.getLinesRangeStatements([refStatement]);
_refPrefix = _refUtils.getNodePrefix(refStatement);
} else {
_refLineRange = null;
_refPrefix = _refUtils.getLinePrefix(_node.offset);
}
}
void _addRefEdit(SourceEdit edit) {
doSourceChange_addElementEdit(ref.change, refElement, edit);
}
bool _canInlineBody(AstNode usage) {
// no statements, usually just expression
if (ref._methodStatementsPart == null) {
// empty method, inline as closure
if (ref._methodExpressionPart == null) {
return false;
}
// OK, just expression
return true;
}
// analyze point of invocation
AstNode parent = usage.parent;
AstNode parent2 = parent.parent;
// OK, if statement in block
if (parent is Statement) {
return parent2 is Block;
}
// maybe assignment, in block
if (parent is AssignmentExpression) {
AssignmentExpression assignment = parent;
// inlining setter
if (assignment.leftHandSide == usage) {
return parent2 is Statement && parent2.parent is Block;
}
// inlining initializer
return ref._methodExpressionPart != null;
}
// maybe value for variable initializer, in block
if (ref._methodExpressionPart != null) {
if (parent is VariableDeclaration) {
if (parent2 is VariableDeclarationList) {
AstNode parent3 = parent2.parent;
return parent3 is VariableDeclarationStatement &&
parent3.parent is Block;
}
}
}
// not in block, cannot inline body
return false;
}
void _inlineMethodInvocation(RefactoringStatus status, Expression usage,
bool cascaded, Expression target, List<Expression> arguments) {
// we don't support cascade
if (cascaded) {
status.addError(
'Cannot inline cascade invocation.', newLocation_fromNode(usage));
}
// can we inline method body into "methodUsage" block?
if (_canInlineBody(usage)) {
// insert non-return statements
if (ref._methodStatementsPart != null) {
// prepare statements source for invocation
String source = _getMethodSourceForInvocation(status,
ref._methodStatementsPart, _refUtils, usage, target, arguments);
source = _refUtils.replaceSourceIndent(
source, ref._methodStatementsPart._prefix, _refPrefix);
// do insert
SourceEdit edit = newSourceEdit_range(
new SourceRange(_refLineRange.offset, 0), source);
_addRefEdit(edit);
}
// replace invocation with return expression
if (ref._methodExpressionPart != null) {
// prepare expression source for invocation
String source = _getMethodSourceForInvocation(status,
ref._methodExpressionPart, _refUtils, usage, target, arguments);
if (getExpressionPrecedence(ref._methodExpression) <
getExpressionParentPrecedence(usage)) {
source = "($source)";
}
// do replace
SourceRange methodUsageRange = range.node(usage);
SourceEdit edit = newSourceEdit_range(methodUsageRange, source);
_addRefEdit(edit);
} else {
SourceEdit edit = newSourceEdit_range(_refLineRange, "");
_addRefEdit(edit);
}
return;
}
// inline as closure invocation
String source;
{
source = ref._methodUtils.getRangeText(range.startEnd(
ref._methodParameters.leftParenthesis, ref._methodNode));
String methodPrefix =
ref._methodUtils.getLinePrefix(ref._methodNode.offset);
source = _refUtils.replaceSourceIndent(source, methodPrefix, _refPrefix);
source = source.trim();
}
// do insert
SourceEdit edit = newSourceEdit_range(range.node(_node), source);
_addRefEdit(edit);
}
void _process(RefactoringStatus status) {
AstNode nodeParent = _node.parent;
// may be only single place should be inlined
if (!_shouldProcess()) {
return;
}
// If the element being inlined is async, ensure that the function
// body that encloses the method is also async.
if (ref._methodElement.isAsynchronous) {
FunctionBody body = _node.getAncestor((n) => n is FunctionBody);
if (body != null) {
if (body.isSynchronous) {
if (body.isGenerator) {
status.addFatalError(
'Cannot inline async into sync*.', newLocation_fromNode(_node));
return;
}
if (refElement is ExecutableElement) {
var executable = refElement as ExecutableElement;
if (!executable.returnType.isDartAsyncFuture) {
status.addFatalError(
'Cannot inline async into a function that does not return a Future.',
newLocation_fromNode(_node));
return;
}
}
if (ref._alreadyMadeAsync.add(body)) {
SourceRange bodyStart = range.startLength(body, 0);
_addRefEdit(newSourceEdit_range(bodyStart, 'async '));
}
}
}
}
// may be invocation of inline method
if (nodeParent is MethodInvocation) {
MethodInvocation invocation = nodeParent;
Expression target = invocation.target;
List<Expression> arguments = invocation.argumentList.arguments;
_inlineMethodInvocation(
status, invocation, invocation.isCascaded, target, arguments);
} else {
// cannot inline reference to method: var v = new A().method;
if (ref._methodElement is MethodElement) {
status.addFatalError('Cannot inline class method reference.',
newLocation_fromNode(_node));
return;
}
// PropertyAccessorElement
if (ref._methodElement is PropertyAccessorElement) {
Expression usage = _node;
Expression target = null;
bool cascade = false;
if (nodeParent is PrefixedIdentifier) {
PrefixedIdentifier propertyAccess = nodeParent;
usage = propertyAccess;
target = propertyAccess.prefix;
cascade = false;
}
if (nodeParent is PropertyAccess) {
PropertyAccess propertyAccess = nodeParent;
usage = propertyAccess;
target = propertyAccess.realTarget;
cascade = propertyAccess.isCascaded;
}
// prepare arguments
List<Expression> arguments = [];
if (_node.inSetterContext()) {
AssignmentExpression assignment =
_node.getAncestor((node) => node is AssignmentExpression);
arguments.add(assignment.rightHandSide);
}
// inline body
_inlineMethodInvocation(status, usage, cascade, target, arguments);
return;
}
// not invocation, just reference to function
String source;
{
source = ref._methodUtils.getRangeText(range.startEnd(
ref._methodParameters.leftParenthesis, ref._methodNode));
String methodPrefix =
ref._methodUtils.getLinePrefix(ref._methodNode.offset);
source =
_refUtils.replaceSourceIndent(source, methodPrefix, _refPrefix);
source = source.trim();
source = removeEnd(source, ';');
}
// do insert
SourceEdit edit = newSourceEdit_range(range.node(_node), source);
_addRefEdit(edit);
}
}
bool _shouldProcess() {
if (!ref.inlineAll) {
SourceRange parentRange = range.node(_node);
return parentRange.contains(ref.offset);
}
return true;
}
}
class _ReturnsValidatorVisitor extends RecursiveAstVisitor {
final RefactoringStatus result;
int _numReturns = 0;
_ReturnsValidatorVisitor(this.result);
@override
visitReturnStatement(ReturnStatement node) {
_numReturns++;
if (_numReturns == 2) {
result.addError('Ambiguous return value.', newLocation_fromNode(node));
}
}
}
/**
* Information about the source of a method being inlined.
*/
class _SourcePart {
/**
* The base for all [SourceRange]s.
*/
final int _base;
/**
* The source of the method.
*/
final String _source;
/**
* The original prefix of the method.
*/
final String _prefix;
/**
* The occurrences of the method parameters.
*/
final Map<ParameterElement, List<_ParameterOccurrence>> _parameters = {};
/**
* The occurrences of the method local variables.
*/
final Map<VariableElement, List<SourceRange>> _variables = {};
/**
* The offsets of explicit `this` expression references.
*/
final List<int> _explicitThisOffsets = [];
/**
* The offsets of implicit `this` expression references.
*/
final List<int> _implicitThisOffsets = [];
/**
* The offsets of the implicit class references in static member references.
*/
final Map<String, List<int>> _implicitClassNameOffsets = {};
_SourcePart(this._base, this._source, this._prefix);
void addExplicitThisOffset(int offset) {
_explicitThisOffsets.add(offset - _base);
}
void addImplicitClassNameOffset(String className, int offset) {
List<int> offsets = _implicitClassNameOffsets[className];
if (offsets == null) {
offsets = [];
_implicitClassNameOffsets[className] = offsets;
}
offsets.add(offset - _base);
}
void addImplicitThisOffset(int offset) {
_implicitThisOffsets.add(offset - _base);
}
void addParameterOccurrence(
ParameterElement parameter, SourceRange identifierRange, int precedence) {
if (parameter != null) {
List<_ParameterOccurrence> occurrences = _parameters[parameter];
if (occurrences == null) {
occurrences = [];
_parameters[parameter] = occurrences;
}
identifierRange = range.offsetBy(identifierRange, -_base);
occurrences.add(new _ParameterOccurrence(precedence, identifierRange));
}
}
void addVariable(VariableElement element, SourceRange identifierRange) {
List<SourceRange> ranges = _variables[element];
if (ranges == null) {
ranges = [];
_variables[element] = ranges;
}
identifierRange = range.offsetBy(identifierRange, -_base);
ranges.add(identifierRange);
}
}
/**
* A visitor that fills [_SourcePart] with fields, parameters and variables.
*/
class _VariablesVisitor extends GeneralizingAstVisitor {
/**
* The [ExecutableElement] being inlined.
*/
final ExecutableElement methodElement;
/**
* The [SourceRange] of the element body.
*/
final SourceRange bodyRange;
/**
* The [_SourcePart] to record reference into.
*/
final _SourcePart result;
int offset;
_VariablesVisitor(this.methodElement, this.bodyRange, this.result);
@override
visitNode(AstNode node) {
SourceRange nodeRange = range.node(node);
if (!bodyRange.intersects(nodeRange)) {
return null;
}
super.visitNode(node);
}
@override
visitSimpleIdentifier(SimpleIdentifier node) {
SourceRange nodeRange = range.node(node);
if (bodyRange.covers(nodeRange)) {
_addMemberQualifier(node);
_addParameter(node);
_addVariable(node);
}
}
@override
visitThisExpression(ThisExpression node) {
int offset = node.offset;
if (bodyRange.contains(offset)) {
result.addExplicitThisOffset(offset);
}
}
void _addMemberQualifier(SimpleIdentifier node) {
// should be unqualified
AstNode qualifier = getNodeQualifier(node);
if (qualifier != null) {
return;
}
// should be a method or field reference
Element element = node.staticElement;
if (!(element is MethodElement || element is PropertyAccessorElement)) {
return;
}
if (element.enclosingElement is! ClassElement) {
return;
}
// record the implicit static or instance reference
ExecutableElement member = element;
int offset = node.offset;
if (member.isStatic) {
String className = member.enclosingElement.displayName;
result.addImplicitClassNameOffset(className, offset);
} else {
result.addImplicitThisOffset(offset);
}
}
void _addParameter(SimpleIdentifier node) {
ParameterElement parameterElement = getParameterElement(node);
// not a parameter
if (parameterElement == null) {
return;
}
// not a parameter of the function being inlined
if (!methodElement.parameters.contains(parameterElement)) {
return;
}
// OK, add occurrence
SourceRange nodeRange = range.node(node);
int parentPrecedence = getExpressionParentPrecedence(node);
result.addParameterOccurrence(
parameterElement, nodeRange, parentPrecedence);
}
void _addVariable(SimpleIdentifier node) {
VariableElement variableElement = getLocalVariableElement(node);
if (variableElement != null) {
SourceRange nodeRange = range.node(node);
result.addVariable(variableElement, nodeRange);
}
}
}