blob: aec0c50e40ff3ac346a243ca99bc211e7c33893a (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*******************************************************************************
* Copyright (c) 2000, 2004 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.core.dom;
import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
/**
* Abstract base class for all AST nodes that represent names.
* There are exactly two kinds of name: simple ones
* (<code>SimpleName</code>) and qualified ones (<code>QualifiedName</code>).
* <p>
* <pre>
* Name:
* SimpleName
* QualifiedName
* </pre>
* </p>
*
* @since 2.0
*/
public abstract class Name extends Expression {
/**
* Approximate base size of an expression node instance in bytes,
* including object header and instance fields.
*/
static final int BASE_NAME_NODE_SIZE = BASE_NODE_SIZE + 1 * 4;
/**
* This index represents the position inside a qualified name.
*/
int index;
/**
* Creates a new AST node for a name owned by the given AST.
* <p>
* N.B. This constructor is package-private.
* </p>
*
* @param ast the AST that is to own this node
*/
Name(AST ast) {
super(ast);
}
/**
* Returns whether this name is a simple name
* (<code>SimpleName</code>).
*
* @return <code>true</code> if this is a simple name, and
* <code>false</code> otherwise
*/
public final boolean isSimpleName() {
return (this instanceof SimpleName);
}
/**
* Returns whether this name is a qualified name
* (<code>QualifiedName</code>).
*
* @return <code>true</code> if this is a qualified name, and
* <code>false</code> otherwise
*/
public final boolean isQualifiedName() {
return (this instanceof QualifiedName);
}
/**
* Resolves and returns the binding for the entity referred to by this name.
* <p>
* Note that bindings are generally unavailable unless requested when the
* AST is being built.
* </p>
*
* @return the binding, or <code>null</code> if the binding cannot be
* resolved
*/
public final IBinding resolveBinding() {
return getAST().getBindingResolver().resolveName(this);
}
BlockScope lookupScope() {
ASTNode currentNode = this;
while(currentNode != null
&&!(currentNode instanceof MethodDeclaration)
&& !(currentNode instanceof Initializer)
&& !(currentNode instanceof FieldDeclaration)) {
currentNode = currentNode.getParent();
}
if (currentNode == null) {
return null;
}
if (currentNode instanceof Initializer) {
Initializer initializer = (Initializer) currentNode;
while(!(currentNode instanceof TypeDeclaration)) {
currentNode = currentNode.getParent();
}
org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDecl = (org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.getAST().getBindingResolver().getCorrespondingNode(currentNode);
if ((initializer.getModifiers() & Modifier.STATIC) != 0) {
return typeDecl.staticInitializerScope;
} else {
return typeDecl.initializerScope;
}
} else if (currentNode instanceof FieldDeclaration) {
FieldDeclaration fieldDeclaration = (FieldDeclaration) currentNode;
while(!(currentNode instanceof TypeDeclaration)) {
currentNode = currentNode.getParent();
}
org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDecl = (org.eclipse.jdt.internal.compiler.ast.TypeDeclaration) this.getAST().getBindingResolver().getCorrespondingNode(currentNode);
if ((fieldDeclaration.getModifiers() & Modifier.STATIC) != 0) {
return typeDecl.staticInitializerScope;
} else {
return typeDecl.initializerScope;
}
}
AbstractMethodDeclaration abstractMethodDeclaration = (AbstractMethodDeclaration) this.getAST().getBindingResolver().getCorrespondingNode(currentNode);
return abstractMethodDeclaration.scope;
}
}
|
