public boolean forFriendship() {
if (astName == null) return false;
IASTNode node = astName.getParent();
while (node instanceof IASTName) node = node.getParent();
IASTDeclaration decl = null;
IASTDeclarator dtor = null;
if (node instanceof ICPPASTDeclSpecifier && node.getParent() instanceof IASTDeclaration) {
decl = (IASTDeclaration) node.getParent();
} else if (node instanceof IASTDeclarator) {
dtor = (IASTDeclarator) node;
while (dtor.getParent() instanceof IASTDeclarator) dtor = (IASTDeclarator) dtor.getParent();
if (!(dtor.getParent() instanceof IASTDeclaration)) return false;
decl = (IASTDeclaration) dtor.getParent();
} else {
return false;
}
if (decl instanceof IASTSimpleDeclaration) {
IASTSimpleDeclaration simple = (IASTSimpleDeclaration) decl;
if (!((ICPPASTDeclSpecifier) simple.getDeclSpecifier()).isFriend()) return false;
if (dtor != null) return true;
return simple.getDeclarators().length == 0;
} else if (decl instanceof IASTFunctionDefinition) {
IASTFunctionDefinition fnDef = (IASTFunctionDefinition) decl;
if (!((ICPPASTDeclSpecifier) fnDef.getDeclSpecifier()).isFriend()) return false;
return (dtor != null);
}
return false;
}
public void testObjectMacroExpansionPartialDeclSpec() throws Exception {
StringBuffer buffer = new StringBuffer("#define XYZ const\n"); // $NON-NLS-1$
buffer.append("XYZ int var;"); // $NON-NLS-1$
String code = buffer.toString();
for (ParserLanguage language : languages) {
IASTTranslationUnit tu = parse(code, language);
IASTPreprocessorObjectStyleMacroDefinition defXYZ =
(IASTPreprocessorObjectStyleMacroDefinition) tu.getMacroDefinitions()[0];
IASTSimpleDeclaration var = (IASTSimpleDeclaration) tu.getDeclarations()[0];
IASTSimpleDeclSpecifier declSpec = (IASTSimpleDeclSpecifier) var.getDeclSpecifier();
IASTNodeLocation[] declSpecLocations = declSpec.getNodeLocations();
assertEquals(declSpecLocations.length, 2);
IASTMacroExpansionLocation expansion = (IASTMacroExpansionLocation) declSpecLocations[0];
assertEqualsMacros(defXYZ, expansion.getExpansion().getMacroDefinition());
assertEquals(expansion.getNodeOffset(), 0);
assertEquals(expansion.getNodeLength(), 1);
IASTNodeLocation[] expansionLocations = expansion.getExpansion().getNodeLocations();
assertEquals(expansionLocations.length, 1);
assertTrue(expansionLocations[0] instanceof IASTFileLocation);
assertEquals(expansionLocations[0].getNodeOffset(), code.indexOf("XYZ int")); // $NON-NLS-1$
assertEquals(expansionLocations[0].getNodeLength(), "XYZ".length()); // $NON-NLS-1$
IASTFileLocation second = (IASTFileLocation) declSpecLocations[1];
assertEquals(second.getNodeOffset(), code.indexOf(" int")); // $NON-NLS-1$
assertEquals(second.getNodeLength(), " int".length()); // $NON-NLS-1$
}
}
// typedef int tint;
// struct X {
// int a;
// } c
// tint b;
public void testCompositeTypeWithDtorWithoutSemi() throws Exception {
final String comment = getAboveComment();
for (ParserLanguage lang : ParserLanguage.values()) {
IASTTranslationUnit tu = parse(comment, lang, false, false);
IASTSimpleDeclaration sdecl = getDeclaration(tu, 1);
assertInstance(sdecl.getDeclSpecifier(), IASTCompositeTypeSpecifier.class);
assertEquals(1, sdecl.getDeclarators().length);
IASTProblemDeclaration pdecl = getDeclaration(tu, 2);
sdecl = getDeclaration(tu, 3);
}
}
@Override
public int getRoleForName(IASTName n) {
// 3.1.2
IASTNode parent = ASTQueries.findOutermostDeclarator(this).getParent();
if (parent instanceof IASTDeclaration) {
// a declaration is a definition unless ...
if (parent instanceof IASTFunctionDefinition) return r_definition;
if (parent instanceof IASTSimpleDeclaration) {
final IASTSimpleDeclaration sdecl = (IASTSimpleDeclaration) parent;
// unless it declares a function without body
if (this instanceof IASTFunctionDeclarator) {
return r_declaration;
}
final int storage = sdecl.getDeclSpecifier().getStorageClass();
// unless it contains the extern specifier or a linkage-specification and neither
// initializer nor function-body
if (getInitializer() == null
&& (storage == IASTDeclSpecifier.sc_extern || isSimpleLinkageSpec(sdecl))) {
return r_declaration;
}
// unless it declares a static data member in a class declaration
if (storage == IASTDeclSpecifier.sc_static
&& CPPVisitor.getContainingScope(parent) instanceof ICPPClassScope) {
return r_declaration;
}
// unless it is a class name declaration: no declarator in this case
// unless it is a typedef declaration
if (storage == IASTDeclSpecifier.sc_typedef)
return r_definition; // should actually be a declaration
// unless it is a using-declaration or using-directive: no declarator in this case
}
// all other cases
return r_definition;
}
if (parent instanceof IASTTypeId) return r_reference;
if (parent instanceof IASTParameterDeclaration)
return (n.getLookupKey().length > 0) ? r_definition : r_declaration;
return r_unclear;
}
private void visitType(IASTSimpleDeclaration declaration) throws BadLocationException {
/* TODO: specific params: include type('class' / 'struct') */
IASTDeclSpecifier spec = declaration.getDeclSpecifier();
if (spec instanceof IASTCompositeTypeSpecifier) {
String hint = ((IASTCompositeTypeSpecifier) spec).getName().getRawSignature();
if (hint.isEmpty()) return;
IASTFileLocation location = declaration.getFileLocation();
int endLoc = location.getNodeOffset() + location.getNodeLength() - 1;
int startLoc = location.getNodeOffset();
_container.add(new Hint("type", startLoc, endLoc, hint)); // $NON-NLS-1$
}
if (spec instanceof ICPPASTNamedTypeSpecifier) {
IASTName name = ((ICPPASTNamedTypeSpecifier) spec).getName();
addBrackets(name);
}
}
/*
* @see org.eclipse.cdt.core.dom.ast.ASTVisitor#leave(org.eclipse.cdt.core.dom.ast.IASTDeclaration)
*/
@Override
public int leave(IASTDeclaration node) {
super.leave(node);
boolean isTemplateDecl = isTemplateDecl(node);
final int endOffset = isTemplateDecl ? getEndOffset(node.getParent()) : getEndOffset(node);
if (node instanceof IASTFunctionDefinition) {
final int nodeType;
if (inClassBody()) {
nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_METHOD : ICElement.C_METHOD;
} else {
nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_FUNCTION : ICElement.C_FUNCTION;
}
assert getCurrentContainer().getTypeCode() == nodeType;
pop(endOffset);
} else if (node instanceof IASTSimpleDeclaration) {
IASTSimpleDeclaration simpleDecl = (IASTSimpleDeclaration) node;
IASTDeclSpecifier declSpec = simpleDecl.getDeclSpecifier();
boolean isCompositeType = false;
if (declSpec instanceof ICPPASTCompositeTypeSpecifier) {
isCompositeType = true;
ICPPASTCompositeTypeSpecifier compositeTypeSpec = (ICPPASTCompositeTypeSpecifier) declSpec;
final int nodeType;
switch (compositeTypeSpec.getKey()) {
case IASTCompositeTypeSpecifier.k_struct:
nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_STRUCT : ICElement.C_STRUCT;
break;
case IASTCompositeTypeSpecifier.k_union:
nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_UNION : ICElement.C_UNION;
break;
case ICPPASTCompositeTypeSpecifier.k_class:
nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_CLASS : ICElement.C_CLASS;
break;
default:
assert false : "Unexpected composite type specifier"; // $NON-NLS-1$
return PROCESS_CONTINUE;
}
assert getCurrentContainer().getTypeCode() == nodeType;
pop(isTemplateDecl ? endOffset : getEndOffset(declSpec));
} else if (declSpec instanceof IASTEnumerationSpecifier) {
isCompositeType = true;
assert getCurrentContainer().getTypeCode() == ICElement.C_ENUMERATION;
pop(getEndOffset(declSpec));
}
if (isCompositeType) {
IASTDeclarator[] declarators = simpleDecl.getDeclarators();
for (int i = 0; i < declarators.length; i++) {
IASTDeclarator declarator = declarators[i];
final String nodeName = getDeclaratorName(declarator);
final int declStartOffset = getStartOffset(declarator);
final int declEndOffset = getEndOffset(declarator);
if (declSpec.getStorageClass() == IASTDeclSpecifier.sc_typedef) {
push(ICElement.C_TYPEDEF, nodeName, declStartOffset);
pop(declEndOffset);
} else if (declarator instanceof IASTFunctionDeclarator
&& !hasNestedPointerOperators(declarator)) {
final int nodeType;
if (inClassBody()) {
nodeType =
isTemplateDecl
? ICElement.C_TEMPLATE_METHOD_DECLARATION
: ICElement.C_METHOD_DECLARATION;
} else {
nodeType =
isTemplateDecl
? ICElement.C_TEMPLATE_FUNCTION_DECLARATION
: ICElement.C_FUNCTION_DECLARATION;
}
push(nodeType, nodeName, declStartOffset);
pop(declEndOffset);
} else if (declarator != null) {
final int nodeType;
if (inClassBody()) {
nodeType = ICElement.C_FIELD;
} else {
if (declSpec.getStorageClass() == IASTDeclSpecifier.sc_extern) {
nodeType = ICElement.C_VARIABLE_DECLARATION;
} else {
nodeType = isTemplateDecl ? ICElement.C_TEMPLATE_VARIABLE : ICElement.C_VARIABLE;
}
}
push(nodeType, nodeName, declStartOffset);
pop(declEndOffset);
}
}
}
} else if (node instanceof IASTASMDeclaration) {
// ignored
} else if (node instanceof ICPPASTVisibilityLabel) {
// ignored
} else if (node instanceof ICPPASTNamespaceDefinition) {
// handled below
} else if (node instanceof ICPPASTNamespaceAlias) {
// ignored
} else if (node instanceof ICPPASTUsingDeclaration) {
// handled in visit
} else if (node instanceof ICPPASTUsingDirective) {
// handled in visit
} else if (node instanceof ICPPASTLinkageSpecification) {
// declarations get flattened
} else if (node instanceof ICPPASTTemplateDeclaration) {
// handled at child declaration level
} else if (node instanceof ICPPASTTemplateSpecialization) {
// ignored
} else if (node instanceof ICPPASTExplicitTemplateInstantiation) {
// ignored
} else if (node instanceof IASTProblemDeclaration) {
// ignored
}
return PROCESS_CONTINUE;
}
