| // 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); | |
| } | |
| } | |
| } |