/*******************************************************************************
* Copyright (c) 2012, 2016 Google, Inc and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Sergey Prigogin (Google) - initial API and implementation
* Mathias Kunter
*******************************************************************************/
package org.eclipse.cdt.internal.ui.refactoring.includes;
import static org.eclipse.cdt.core.index.IndexLocationFactory.getAbsolutePath;
import static org.eclipse.cdt.internal.ui.refactoring.includes.IncludeUtil.isContainedInRegion;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.text.IRegion;
import org.eclipse.text.edits.DeleteEdit;
import org.eclipse.text.edits.InsertEdit;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.ReplaceEdit;
import com.ibm.icu.text.Collator;
import org.eclipse.cdt.core.dom.IName;
import org.eclipse.cdt.core.dom.ast.ASTTypeUtil;
import org.eclipse.cdt.core.dom.ast.DOMException;
import org.eclipse.cdt.core.dom.ast.EScopeKind;
import org.eclipse.cdt.core.dom.ast.IASTComment;
import org.eclipse.cdt.core.dom.ast.IASTFileLocation;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTPreprocessorIncludeStatement;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.ICompositeType;
import org.eclipse.cdt.core.dom.ast.IEnumeration;
import org.eclipse.cdt.core.dom.ast.IFunction;
import org.eclipse.cdt.core.dom.ast.IFunctionType;
import org.eclipse.cdt.core.dom.ast.IMacroBinding;
import org.eclipse.cdt.core.dom.ast.IParameter;
import org.eclipse.cdt.core.dom.ast.IScope;
import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.IVariable;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateDefinition;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameter;
import org.eclipse.cdt.core.index.IIndex;
import org.eclipse.cdt.core.index.IIndexFile;
import org.eclipse.cdt.core.index.IIndexFileLocation;
import org.eclipse.cdt.core.index.IIndexFileSet;
import org.eclipse.cdt.core.index.IIndexInclude;
import org.eclipse.cdt.core.index.IIndexName;
import org.eclipse.cdt.core.model.ITranslationUnit;
import org.eclipse.cdt.core.parser.util.ArrayUtil;
import org.eclipse.cdt.ui.CUIPlugin;
import org.eclipse.cdt.ui.CodeGeneration;
import org.eclipse.cdt.internal.core.dom.rewrite.commenthandler.ASTCommenter;
import org.eclipse.cdt.internal.core.dom.rewrite.commenthandler.NodeCommentMap;
import org.eclipse.cdt.internal.core.dom.rewrite.util.ASTNodes;
import org.eclipse.cdt.internal.core.parser.scanner.ILocationResolver;
import org.eclipse.cdt.internal.core.util.TextUtil;
import org.eclipse.cdt.internal.corext.codemanipulation.IncludeInfo;
import org.eclipse.cdt.internal.corext.codemanipulation.StyledInclude;
import org.eclipse.cdt.internal.formatter.ChangeFormatter;
/**
* Organizes the include directives and forward declarations of a source or header file.
*/
public class IncludeOrganizer {
private static boolean DEBUG_HEADER_SUBSTITUTION =
Boolean.parseBoolean(Platform.getDebugOption(CUIPlugin.PLUGIN_ID + "/debug/includeOrganizer/headerSubstitution")); //$NON-NLS-1$
private static final Collator COLLATOR = Collator.getInstance();
/**
* Represents a new or an existing include statement.
*/
private static class IncludePrototype extends StyledInclude {
private final boolean required; // true if the header has to be included
/** Initializes an include prototype object for a new include */
IncludePrototype(IPath header, IncludeInfo includeInfo, IncludeGroupStyle style) {
super(header, includeInfo, style);
this.required = true;
}
/**
* Initializes an include prototype object for an existing include. {@code header} may be
* {@code null} if the include was not resolved.
*/
IncludePrototype(IPath header, IncludeInfo includeInfo, IncludeGroupStyle style,
IASTPreprocessorIncludeStatement existingInclude, boolean required) {
super(header, includeInfo, style, existingInclude);
this.required = required;
}
public boolean isRequired() {
return required;
}
}
private static enum DeclarationType { TYPE, FUNCTION, VARIABLE, NAMESPACE }
private static class ForwardDeclarationNode implements Comparable<ForwardDeclarationNode> {
final String name;
final String declaration;
final DeclarationType type;
final List<ForwardDeclarationNode> children;
/**
* Creates a namespace node.
*/
ForwardDeclarationNode(String name) {
this.name = name;
this.declaration = null;
this.type = DeclarationType.NAMESPACE;
this.children = new ArrayList<>();
}
/**
* Creates a declaration node.
*/
ForwardDeclarationNode(String name, String declaration, DeclarationType type) {
this.name = name;
this.declaration = declaration;
this.type = type;
this.children = null;
}
ForwardDeclarationNode findOrAddChild(ForwardDeclarationNode node) {
int i = Collections.binarySearch(children, node);
if (i >= 0)
return children.get(i);
children.add(-(i + 1), node);
return node;
}
@Override
public int compareTo(ForwardDeclarationNode other) {
int c = type.ordinal() - other.type.ordinal();
if (c != 0)
return c;
c = COLLATOR.compare(name, other.name);
if (declaration == null || c != 0)
return c;
return COLLATOR.compare(declaration, other.declaration);
}
}
private final IHeaderChooser fHeaderChooser;
private final IncludeCreationContext fContext;
public IncludeOrganizer(ITranslationUnit tu, IIndex index, IHeaderChooser headerChooser) {
fHeaderChooser = headerChooser;
fContext = new IncludeCreationContext(tu, index);
}
/**
* Organizes the includes for a given translation unit.
*
* @param ast The AST translation unit to process.
*/
public MultiTextEdit organizeIncludes(IASTTranslationUnit ast) throws CoreException {
// Process the given translation unit with the inclusion resolver.
BindingClassifier bindingClassifier = new BindingClassifier(fContext);
bindingClassifier.classifyNodeContents(ast);
Set<IBinding> bindingsToInclude = bindingClassifier.getBindingsToDefine();
IASTPreprocessorIncludeStatement[] existingIncludes = ast.getIncludeDirectives();
fContext.addHeadersIncludedPreviously(existingIncludes);
HeaderSubstitutor headerSubstitutor = new HeaderSubstitutor(fContext);
// Create the list of header files which have to be included by examining the list of
// bindings which have to be defined.
IIndexFileSet reachableHeaders = ast.getIndexFileSet();
List<InclusionRequest> requests = createInclusionRequests(ast, bindingsToInclude, false, reachableHeaders);
processInclusionRequests(requests, existingIncludes, headerSubstitutor);
NodeCommentMap commentedNodeMap = ASTCommenter.getCommentedNodeMap(ast);
// Use a map instead of a set to be able to retrieve existing elements using equal elements.
// Maps each element to itself.
Map<IncludePrototype, IncludePrototype> includePrototypes = new HashMap<>();
// Put the new includes into includePrototypes.
for (IPath header : fContext.getHeadersToInclude()) {
IncludeGroupStyle style = fContext.getIncludeStyle(header);
IncludeInfo includeInfo = fContext.createIncludeInfo(header, style);
IncludePrototype prototype = new IncludePrototype(header, includeInfo, style);
updateIncludePrototypes(includePrototypes, prototype);
}
// Add existing includes to includePrototypes.
for (IASTPreprocessorIncludeStatement include : existingIncludes) {
if (include.isPartOfTranslationUnitFile()) {
String name = new String(include.getName().getSimpleID());
IncludeInfo includeInfo = new IncludeInfo(name, include.isSystemInclude());
String path = include.getPath();
// An empty path means that the include was not resolved.
IPath header = path.isEmpty() ? null : Path.fromOSString(path);
IncludeGroupStyle style =
header != null ? fContext.getIncludeStyle(header) : fContext.getIncludeStyle(includeInfo);
boolean required = hasPragmaKeep(include, commentedNodeMap);
IncludePrototype prototype = new IncludePrototype(header, includeInfo, style, include, required);
updateIncludePrototypes(includePrototypes, prototype);
}
}
IRegion includeReplacementRegion =
IncludeUtil.getSafeIncludeReplacementRegion(fContext.getSourceContents(), ast, commentedNodeMap);
IncludePreferences preferences = fContext.getPreferences();
boolean allowReordering = preferences.allowReordering || existingIncludes.length == 0;
MultiTextEdit rootEdit = new MultiTextEdit();
@SuppressWarnings("unchecked")
List<IncludePrototype>[] groupedPrototypes =
(List<IncludePrototype>[]) new List<?>[preferences.includeStyles.size()];
for (IncludePrototype prototype : includePrototypes.keySet()) {
if (prototype.getExistingInclude() == null
|| (allowReordering && isContainedInRegion(prototype.getExistingInclude(), includeReplacementRegion))) {
IncludeGroupStyle groupingStyle = prototype.getStyle().getGroupingStyle(preferences.includeStyles);
// If reordering is not allowed, group everything together.
int position = allowReordering ? groupingStyle.getOrder() : 0;
List<IncludePrototype> prototypes = groupedPrototypes[position];
if (prototypes == null) {
prototypes = new ArrayList<>();
groupedPrototypes[position] = prototypes;
}
prototypes.add(prototype);
}
if (!allowReordering && prototype.getExistingInclude() != null
&& !prototype.isRequired() && prototype.getHeader() != null // Unused and resolved.
&& !fContext.isPartnerFile(prototype.getHeader())
&& isContainedInRegion(prototype.getExistingInclude(), includeReplacementRegion)) {
switch (preferences.unusedStatementsDisposition) {
case REMOVE:
createDelete(prototype.getExistingInclude(), rootEdit);
break;
case COMMENT_OUT:
createCommentOut(prototype.getExistingInclude(), rootEdit);
break;
case KEEP:
break;
}
}
}
List<String> includeDirectives = new ArrayList<>();
IncludeGroupStyle previousStyle = null;
for (List<IncludePrototype> prototypes : groupedPrototypes) {
if (prototypes != null && !prototypes.isEmpty()) {
Collections.sort(prototypes, preferences);
IncludeGroupStyle style = prototypes.get(0).getStyle();
if (!includeDirectives.isEmpty() &&
style.isBlankLineNeededAfter(previousStyle, preferences.includeStyles)) {
includeDirectives.add(""); // Blank line separator //$NON-NLS-1$
}
previousStyle = style;
for (IncludePrototype prototype : prototypes) {
String trailingComment = ""; //$NON-NLS-1$
IASTPreprocessorIncludeStatement include = prototype.getExistingInclude();
if (include == null
|| (allowReordering && IncludeUtil.isContainedInRegion(include, includeReplacementRegion))) {
if (include != null) {
List<IASTComment> comments = commentedNodeMap.getTrailingCommentsForNode(include);
StringBuilder buf = new StringBuilder();
for (IASTComment comment : comments) {
buf.append(ASTNodes.getPrecedingWhitespaceInLine(fContext.getSourceContents(), comment));
buf.append(comment.getRawSignature());
}
trailingComment = buf.toString();
}
String directive = createIncludeDirective(prototype, trailingComment);
if (directive != null)
includeDirectives.add(directive);
}
}
}
}
// Create the source code to insert into the editor.
StringBuilder buf = new StringBuilder();
for (String include : includeDirectives) {
buf.append(include);
buf.append(fContext.getLineDelimiter());
}
int offset = includeReplacementRegion.getOffset();
int length = includeReplacementRegion.getLength();
if (allowReordering) {
if (buf.length() != 0) {
if (offset != 0 && !TextUtil.isPreviousLineBlank(fContext.getSourceContents(), offset))
buf.insert(0, fContext.getLineDelimiter()); // Blank line before.
}
String text = buf.toString();
// TODO(sprigogin): Add a diff algorithm and produce narrower replacements.
if (text.length() != length ||
!fContext.getSourceContents().regionMatches(offset, text, 0, length)) {
rootEdit.addChild(new ReplaceEdit(offset, length, text));
}
} else if (buf.length() != 0) {
offset += length;
rootEdit.addChild(new InsertEdit(offset, buf.toString()));
}
createForwardDeclarations(ast, bindingClassifier,
includeReplacementRegion.getOffset() + includeReplacementRegion.getLength(),
buf.length() != 0, rootEdit);
return ChangeFormatter.formatChangedCode(new String(fContext.getSourceContents()), fContext.getTranslationUnit(), rootEdit);
}
/**
* Creates forward declarations by examining the list of bindings which have to be declared.
*/
private void createForwardDeclarations(IASTTranslationUnit ast, BindingClassifier classifier,
int offset, boolean pendingBlankLine, MultiTextEdit rootEdit) throws CoreException {
ForwardDeclarationNode typeDeclarationsRoot = new ForwardDeclarationNode(""); //$NON-NLS-1$
ForwardDeclarationNode nonTypeDeclarationsRoot = new ForwardDeclarationNode(""); //$NON-NLS-1$
IIndexFileSet reachableHeaders = ast.getIndexFileSet();
Set<IBinding> bindings =
removeBindingsDefinedInIncludedHeaders(ast, classifier.getBindingsToForwardDeclare(), reachableHeaders);
for (IBinding binding : bindings) {
// Create the text of the forward declaration of this binding.
StringBuilder declarationText = new StringBuilder();
DeclarationType declarationType;
// Check the type of the binding and create a corresponding forward declaration text.
if (binding instanceof ICompositeType) {
declarationType = DeclarationType.TYPE;
// Forward declare a composite type.
ICompositeType compositeType = (ICompositeType) binding;
// Check whether this is a template type.
ICPPTemplateDefinition templateDefinition = null;
if (compositeType instanceof ICPPTemplateDefinition) {
templateDefinition = (ICPPTemplateDefinition) compositeType;
} else if (compositeType instanceof ICPPTemplateInstance) {
templateDefinition = ((ICPPTemplateInstance) compositeType).getTemplateDefinition();
}
if (templateDefinition != null) {
// Create the template text.
declarationText.append("template "); //$NON-NLS-1$
ICPPTemplateParameter[] templateParameters = templateDefinition.getTemplateParameters();
for (int i = 0; i < templateParameters.length; i++) {
ICPPTemplateParameter templateParameter = templateParameters[i];
if (i == 0) {
declarationText.append("<"); //$NON-NLS-1$
}
declarationText.append("typename "); //$NON-NLS-1$
declarationText.append(templateParameter.getName());
if (i != templateParameters.length - 1) {
declarationText.append(", "); //$NON-NLS-1$
}
}
if (templateParameters.length > 0) {
declarationText.append("> "); //$NON-NLS-1$
}
}
// Append the corresponding keyword.
switch (compositeType.getKey()) {
case ICPPClassType.k_class:
declarationText.append("class"); //$NON-NLS-1$
break;
case ICompositeType.k_struct:
declarationText.append("struct"); //$NON-NLS-1$
break;
case ICompositeType.k_union:
declarationText.append("union"); //$NON-NLS-1$
break;
}
// Append the name of the composite type.
declarationText.append(' ');
declarationText.append(binding.getName());
// Append the semicolon.
declarationText.append(';');
} else if (binding instanceof IEnumeration) {
declarationType = DeclarationType.TYPE;
// Forward declare an enumeration class (C++11 syntax).
declarationText.append("enum class "); //$NON-NLS-1$
declarationText.append(binding.getName());
declarationText.append(';');
} else if (binding instanceof IFunction && !(binding instanceof ICPPMethod)) {
declarationType = DeclarationType.FUNCTION;
// Forward declare a C-style function.
IFunction function = (IFunction) binding;
// Append return type and function name.
IFunctionType functionType = function.getType();
// TODO(sprigogin): Switch to ASTWriter since ASTTypeUtil doesn't properly handle namespaces.
declarationText.append(ASTTypeUtil.getType(functionType.getReturnType(), false));
declarationText.append(' ');
declarationText.append(function.getName());
declarationText.append('(');
// Append parameter types and names.
IType[] parameterTypes = functionType.getParameterTypes();
IParameter[] parameters = function.getParameters();
for (int i = 0; i < parameterTypes.length && i < parameters.length; i++) {
if (i != 0) {
declarationText.append(", "); //$NON-NLS-1$
}
declarationText.append(ASTTypeUtil.getType(parameterTypes[i], false));
char lastChar = declarationText.charAt(declarationText.length() - 1);
if (lastChar != '*' && lastChar != '&') {
// Append a space to separate the type name from the parameter name.
declarationText.append(' ');
}
declarationText.append(parameters[i].getName());
}
declarationText.append(");"); //$NON-NLS-1$
} else if (binding instanceof IVariable) {
declarationType = DeclarationType.VARIABLE;
IVariable variable = (IVariable) binding;
IType variableType = variable.getType();
declarationText.append("extern "); //$NON-NLS-1$
declarationText.append(ASTTypeUtil.getType(variableType, false));
declarationText.append(' ');
declarationText.append(variable.getName());
declarationText.append(';');
} else {
CUIPlugin.log(new IllegalArgumentException(
"Unexpected type of binding " + binding.getName() + //$NON-NLS-1$
" - " + binding.getClass().getSimpleName())); //$NON-NLS-1$
continue;
}
// Consider the namespace(s) of the binding.
List<String> namespaces = new ArrayList<>();
try {
IScope scope = binding.getScope();
while (scope != null && scope.getKind() == EScopeKind.eNamespace) {
IName scopeName = scope.getScopeName();
if (scopeName != null) {
namespaces.add(new String(scopeName.getSimpleID()));
}
scope = scope.getParent();
}
} catch (DOMException e) {
}
ForwardDeclarationNode parentNode = declarationType == DeclarationType.TYPE ?
typeDeclarationsRoot : nonTypeDeclarationsRoot;
Collections.reverse(namespaces);
for (String ns : namespaces) {
ForwardDeclarationNode node = new ForwardDeclarationNode(ns);
parentNode = parentNode.findOrAddChild(node);
}
ForwardDeclarationNode node =
new ForwardDeclarationNode(binding.getName(), declarationText.toString(), declarationType);
parentNode.findOrAddChild(node);
}
StringBuilder buf = new StringBuilder();
for (ForwardDeclarationNode node : typeDeclarationsRoot.children) {
if (pendingBlankLine) {
buf.append(fContext.getLineDelimiter());
pendingBlankLine = false;
}
printNode(node, buf);
}
for (ForwardDeclarationNode node : nonTypeDeclarationsRoot.children) {
if (pendingBlankLine) {
buf.append(fContext.getLineDelimiter());
pendingBlankLine = false;
}
printNode(node, buf);
}
if ((pendingBlankLine || buf.length() != 0) && !isBlankLineOrEndOfFile(offset))
buf.append(fContext.getLineDelimiter());
if (buf.length() != 0)
rootEdit.addChild(new InsertEdit(offset, buf.toString()));
}
private void printNode(ForwardDeclarationNode node, StringBuilder buf) throws CoreException {
if (node.declaration == null) {
buf.append(CodeGeneration.getNamespaceBeginContent(fContext.getTranslationUnit(), node.name, fContext.getLineDelimiter()));
for (ForwardDeclarationNode child : node.children) {
printNode(child, buf);
}
buf.append(CodeGeneration.getNamespaceEndContent(fContext.getTranslationUnit(), node.name, fContext.getLineDelimiter()));
} else {
buf.append(node.declaration);
}
buf.append(fContext.getLineDelimiter());
}
private void createCommentOut(IASTPreprocessorIncludeStatement include, MultiTextEdit rootEdit) {
IASTFileLocation location = include.getFileLocation();
int offset = location.getNodeOffset();
if (fContext.getTranslationUnit().isCXXLanguage()) {
offset = TextUtil.getLineStart(fContext.getSourceContents(), offset);
rootEdit.addChild(new InsertEdit(offset, "//")); //$NON-NLS-1$
} else {
rootEdit.addChild(new InsertEdit(offset, "/*")); //$NON-NLS-1$
int endOffset = offset + location.getNodeLength();
rootEdit.addChild(new InsertEdit(endOffset, "*/")); //$NON-NLS-1$
}
}
private void createDelete(IASTPreprocessorIncludeStatement include, MultiTextEdit rootEdit) {
IASTFileLocation location = include.getFileLocation();
int offset = location.getNodeOffset();
int endOffset = offset + location.getNodeLength();
offset = TextUtil.getLineStart(fContext.getSourceContents(), offset);
endOffset = TextUtil.skipToNextLine(fContext.getSourceContents(), endOffset);
rootEdit.addChild(new DeleteEdit(offset, endOffset - offset));
}
private void updateIncludePrototypes(Map<IncludePrototype, IncludePrototype> includePrototypes,
IncludePrototype prototype) {
IncludePrototype existing = includePrototypes.get(prototype);
if (existing == null) {
includePrototypes.put(prototype, prototype);
} else {
existing.setExistingInclude(prototype.getExistingInclude());
}
}
/**
* Returns {@code true} if there are no non-whitespace characters between the given
* {@code offset} and the end of the line.
*/
private boolean isBlankLineOrEndOfFile(int offset) {
String contents = fContext.getSourceContents();
while (offset < contents.length()) {
char c = contents.charAt(offset++);
if (c == '\n')
return true;
if (!Character.isWhitespace(c))
return false;
}
return true;
}
private Set<IBinding> removeBindingsDefinedInIncludedHeaders(IASTTranslationUnit ast,
Set<IBinding> bindings, IIndexFileSet reachableHeaders) throws CoreException {
List<InclusionRequest> requests = createInclusionRequests(ast, bindings, true, reachableHeaders);
Set<IPath> allIncludedHeaders = new HashSet<>();
allIncludedHeaders.addAll(fContext.getHeadersAlreadyIncluded());
allIncludedHeaders.addAll(fContext.getHeadersToInclude());
Set<IBinding> filteredBindings = new HashSet<>(bindings);
for (InclusionRequest request : requests) {
if (isSatisfiedByIncludedHeaders(request, allIncludedHeaders))
filteredBindings.remove(request.getBinding());
}
return filteredBindings;
}
protected boolean isSatisfiedByIncludedHeaders(InclusionRequest request, Set<IPath> includedHeaders)
throws CoreException {
for (IIndexFile file : request.getDeclaringFiles().keySet()) {
IPath path = getAbsolutePath(file.getLocation());
if (includedHeaders.contains(path))
return true;
IIndexInclude[] includedBy = fContext.getIndex().findIncludedBy(file, IIndex.DEPTH_INFINITE);
for (IIndexInclude include : includedBy) {
path = getAbsolutePath(include.getIncludedByLocation());
if (includedHeaders.contains(path))
return true;
}
}
return false;
}
private void processInclusionRequests(List<InclusionRequest> requests,
IASTPreprocessorIncludeStatement[] existingIncludes, HeaderSubstitutor headerSubstitutor)
throws CoreException {
// Add partner header if necessary.
IIndexFile partnerHeader = null;
for (InclusionRequest request : requests) {
List<IPath> candidatePaths = request.getCandidatePaths();
if (candidatePaths.size() == 1) {
IPath path = candidatePaths.iterator().next();
if (fContext.isPartnerFile(path)) {
request.resolve(path);
fContext.addHeaderToInclude(path);
partnerHeader = request.getDeclaringFiles().keySet().iterator().next();
break;
}
}
}
if (fContext.getPreferences().allowPartnerIndirectInclusion) {
// Mark all headers included by the partner header as already included.
if (partnerHeader == null) {
for (IASTPreprocessorIncludeStatement include : existingIncludes) {
if (include.isPartOfTranslationUnitFile()) {
IIndexFile header = include.getImportedIndexFile();
if (header != null) {
if (fContext.isPartnerFile(new Path(include.getPath()))) {
partnerHeader = header;
break;
}
}
}
}
}
if (partnerHeader != null) {
for (IIndexInclude include : partnerHeader.getIncludes()) {
IIndexFileLocation headerLocation = include.getIncludesLocation();
if (headerLocation != null) {
fContext.addHeaderAlreadyIncluded(getAbsolutePath(headerLocation));
}
}
}
}
// Process headers that are either indirectly included or have unique representatives.
for (InclusionRequest request : requests) {
if (!request.isResolved() && !isExportedBinding(request, headerSubstitutor)) {
List<IPath> candidatePaths = request.getCandidatePaths();
Set<IPath> representativeHeaders = new HashSet<>();
Set<IPath> representedHeaders = new HashSet<>();
boolean allRepresented = true;
for (IPath path : candidatePaths) {
if (fContext.isIncluded(path)) {
request.resolve(path);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() +
(fContext.isToBeIncluded(path) ? " (decided earlier)" : " (was previously included)")); //$NON-NLS-1$ //$NON-NLS-2$
}
break;
} else {
IPath header = headerSubstitutor.getUniqueRepresentativeHeader(path);
if (header != null) {
representativeHeaders.add(header);
representedHeaders.add(path);
} else {
allRepresented = false;
}
}
}
if (!request.isResolved() && allRepresented && representativeHeaders.size() == 1) {
IPath path = representativeHeaders.iterator().next();
request.resolve(path);
if (DEBUG_HEADER_SUBSTITUTION)
System.out.println(request.toString() + " (unique representative)"); //$NON-NLS-1$
if (!fContext.isAlreadyIncluded(path))
fContext.addHeaderToInclude(path);
for (IPath header : representedHeaders) {
if (!header.equals(path))
fContext.addHeaderAlreadyIncluded(header);
}
}
}
}
// Process remaining unambiguous inclusion requests.
for (InclusionRequest request : requests) {
if (!request.isResolved() && !isExportedBinding(request, headerSubstitutor)) {
List<IPath> candidatePaths = request.getCandidatePaths();
if (candidatePaths.size() == 1) {
IPath path = candidatePaths.iterator().next();
if (fContext.isIncluded(path)) {
request.resolve(path);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() +
(fContext.isToBeIncluded(path) ? " (decided earlier)" : " (was previously included)")); //$NON-NLS-1$ //$NON-NLS-2$
}
} else {
IPath header = headerSubstitutor.getPreferredRepresentativeHeader(path);
if (header.equals(path) && fContext.getPreferences().heuristicHeaderSubstitution) {
header = headerSubstitutor.getPreferredRepresentativeHeaderByHeuristic(request, header);
}
request.resolve(header);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() + " (preferred representative)"); //$NON-NLS-1$
}
if (!fContext.isAlreadyIncluded(header))
fContext.addHeaderToInclude(header);
if (!header.equals(path))
fContext.addHeaderAlreadyIncluded(path);
}
}
}
}
// Resolve ambiguous inclusion requests.
for (InclusionRequest request : requests) {
if (!request.isResolved() && !isExportedBinding(request, headerSubstitutor)) {
List<IPath> candidatePaths = request.getCandidatePaths();
for (IPath path : candidatePaths) {
if (fContext.isIncluded(path)) {
request.resolve(path);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() +
(fContext.isToBeIncluded(path) ? " (decided earlier)" : " (was previously included)")); //$NON-NLS-1$ //$NON-NLS-2$
}
break;
}
}
if (!request.isResolved()) {
IPath header = fHeaderChooser.chooseHeader(request.getBinding().getName(), candidatePaths);
if (header == null)
throw new OperationCanceledException();
request.resolve(header);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() + " (user's choice)"); //$NON-NLS-1$
}
if (!fContext.isAlreadyIncluded(header))
fContext.addHeaderToInclude(header);
}
}
}
// Resolve requests for exported symbols.
for (InclusionRequest request : requests) {
if (!request.isResolved()) {
IPath firstIncludedPreviously = null;
Set<IncludeInfo> exportingHeaders = getExportingHeaders(request, headerSubstitutor);
for (IncludeInfo header : exportingHeaders) {
IPath path = fContext.resolveInclude(header);
if (path != null) {
if (fContext.isIncluded(path)) {
request.resolve(path);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() +
(fContext.isToBeIncluded(path) ? " (decided earlier)" : " (was previously included)")); //$NON-NLS-1$ //$NON-NLS-2$
}
break;
}
if (firstIncludedPreviously == null && fContext.wasIncludedPreviously(path))
firstIncludedPreviously = path;
}
}
if (request.isResolved())
continue;
List<IPath> candidatePaths = request.getCandidatePaths();
for (IPath path : candidatePaths) {
if (fContext.isIncluded(path)) {
request.resolve(path);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() +
(fContext.isToBeIncluded(path) ? " (decided earlier)" : " (was previously included)")); //$NON-NLS-1$ //$NON-NLS-2$
}
break;
}
if (firstIncludedPreviously == null && fContext.wasIncludedPreviously(path))
firstIncludedPreviously = path;
}
if (request.isResolved())
continue;
if (firstIncludedPreviously != null) {
request.resolve(firstIncludedPreviously);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() + " (present in old includes)"); //$NON-NLS-1$
}
if (!fContext.isAlreadyIncluded(firstIncludedPreviously))
fContext.addHeaderToInclude(firstIncludedPreviously);
}
if (!request.isResolved()) {
IPath header = fHeaderChooser.chooseHeader(request.getBinding().getName(), candidatePaths);
if (header == null)
throw new OperationCanceledException();
request.resolve(header);
if (DEBUG_HEADER_SUBSTITUTION) {
System.out.println(request.toString() +
(candidatePaths.size() == 1 ? " (the only choice)" : " (user's choice)")); //$NON-NLS-1$ //$NON-NLS-2$
}
if (!fContext.isAlreadyIncluded(header))
fContext.addHeaderToInclude(header);
}
}
}
// Remove headers that are exported by other headers.
fContext.removeExportedHeaders();
}
private boolean isExportedBinding(InclusionRequest request, HeaderSubstitutor headerSubstitutor) {
return !getExportingHeaders(request, headerSubstitutor).isEmpty();
}
private Set<IncludeInfo> getExportingHeaders(InclusionRequest request, HeaderSubstitutor headerSubstitutor) {
String symbol = request.getBindingQualifiedName();
if (symbol == null)
return Collections.emptySet();
return headerSubstitutor.getExportingHeaders(symbol);
}
private List<InclusionRequest> createInclusionRequests(IASTTranslationUnit ast,
Set<IBinding> bindingsToInclude, boolean allowDeclarations,
IIndexFileSet reachableHeaders) throws CoreException {
List<InclusionRequest> requests = new ArrayList<>(bindingsToInclude.size());
IIndex index = fContext.getIndex();
binding_loop: for (IBinding binding : bindingsToInclude) {
IIndexName[] indexNames;
if (binding instanceof IMacroBinding) {
indexNames = IIndexName.EMPTY_ARRAY;
ILocationResolver resolver = ast.getAdapter(ILocationResolver.class);
IASTName[] declarations = resolver.getDeclarations((IMacroBinding) binding);
for (IASTName name : declarations) {
if (name instanceof IAdaptable) {
IIndexName indexName = ((IAdaptable) name).getAdapter(IIndexName.class);
if (indexName != null) {
indexNames = Arrays.copyOf(indexNames, indexNames.length + 1);
indexNames[indexNames.length - 1] = indexName;
}
}
}
} else if (allowDeclarations || binding instanceof IVariable) {
// For a variable we need to include a declaration.
indexNames = index.findDeclarations(binding);
} else if (binding instanceof ICPPMethod) {
// Include the headers containing method definitions except the ones also containing
// the definition of the owner class. The definition of owner class will be included because
// BindingClassifier must add a binding that is either the owner itself, or its subclass, or
// a typedef pointing to it.
Set<IIndexFile> declarationFiles = new HashSet<>();
IIndexName[] declarations = index.findNames(binding, IIndex.FIND_DECLARATIONS);
for (IIndexName declaration : declarations) {
IIndexFile file = declaration.getFile();
if (file != null) {
declarationFiles.add(file);
}
}
IIndexName[] definitions = index.findDefinitions(binding);
indexNames = filterIncludableNotInBlacklistedFiles(definitions, declarationFiles);
} else {
indexNames = index.findDefinitions(binding);
if (binding instanceof IFunction) {
// If a function is defined in a header, include that header.
// Otherwise look for declarations.
indexNames = filterIncludableNotInBlacklistedFiles(indexNames, Collections.<IIndexFile>emptySet());
}
if (indexNames.length == 0) {
// If we could not find any definitions, there is still a chance that
// a declaration would be sufficient.
indexNames = index.findDeclarations(binding);
}
}
if (indexNames.length != 0) {
// Check whether the index name is (also) present within the current file.
// If yes, we don't need to include anything.
for (IIndexName indexName : indexNames) {
IIndexFile indexFile = indexName.getFile();
if (indexFile.getLocation().getURI().equals(fContext.getTranslationUnit().getLocationURI())) {
continue binding_loop;
}
}
Map<IIndexFile, IPath> declaringHeaders = new HashMap<>();
Map<IIndexFile, IPath> reachableDeclaringHeaders = new HashMap<>();
for (IIndexName indexName : indexNames) {
IIndexFile indexFile = indexName.getFile();
if (!fContext.canBeIncluded(indexFile)) {
// The target is a source file which isn't included by any other files.
// Don't include it.
continue;
}
IPath path = getAbsolutePath(indexFile.getLocation());
declaringHeaders.put(indexFile, path);
if (reachableHeaders.contains(indexFile))
reachableDeclaringHeaders.put(indexFile, path);
}
if (!declaringHeaders.isEmpty()) {
boolean reachable = false;
if (!reachableDeclaringHeaders.isEmpty()) {
reachable = true;
declaringHeaders = reachableDeclaringHeaders;
}
requests.add(new InclusionRequest(binding, declaringHeaders, reachable));
}
}
}
return requests;
}
private IIndexName[] filterIncludableNotInBlacklistedFiles(IIndexName[] names, Set<IIndexFile> blacklist)
throws CoreException {
IIndexName[] includable = IIndexName.EMPTY_ARRAY;
int pos = 0;
for (IIndexName name : names) {
IIndexFile file = name.getFile();
if (file != null && !blacklist.contains(file) && fContext.canBeIncluded(file))
includable = ArrayUtil.appendAt(includable, pos++, name);
}
return ArrayUtil.trim(includable, pos);
}
private String createIncludeDirective(IncludePrototype include, String lineComment) {
StringBuilder buf = new StringBuilder();
// Unresolved includes are preserved out of caution. Partner include is always preserved.
if (!include.isRequired() && include.getHeader() != null
&& !fContext.isPartnerFile(include.getHeader())) {
switch (fContext.getPreferences().unusedStatementsDisposition) {
case REMOVE:
return null;
case COMMENT_OUT:
buf.append("//"); //$NON-NLS-1$
break;
case KEEP:
break;
}
}
buf.append(include.getIncludeInfo().composeIncludeStatement());
buf.append(lineComment);
return buf.toString();
}
private boolean hasPragmaKeep(IASTPreprocessorIncludeStatement include, NodeCommentMap commentedNodeMap) {
List<IASTComment> comments = commentedNodeMap.getTrailingCommentsForNode(include);
for (IASTComment comment : comments) {
String text = getTrimmedCommentText(comment);
if (fContext.getKeepPragmaPattern().matcher(text).matches())
return true;
}
return false;
}
private String getTrimmedCommentText(IASTComment comment) {
char[] text = comment.getComment();
int end = text.length - (comment.isBlockComment() ? 2 : 0);
int begin;
for (begin = 2; begin < end; begin++) {
if (!Character.isWhitespace(text[begin]))
break;
}
if (end <= begin)
return ""; //$NON-NLS-1$
while (--end >= begin) {
if (!Character.isWhitespace(text[end]))
break;
}
return new String(text, begin, end + 1 - begin);
}
}