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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*******************************************************************************
* 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.internal.compiler.ast;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.impl.*;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.lookup.*;
public class LocalDeclaration extends AbstractVariableDeclaration {
public LocalVariableBinding binding;
public LocalDeclaration(
char[] name,
int sourceStart,
int sourceEnd) {
this.name = name;
this.sourceStart = sourceStart;
this.sourceEnd = sourceEnd;
this.declarationEnd = sourceEnd;
}
public FlowInfo analyseCode(
BlockScope currentScope,
FlowContext flowContext,
FlowInfo flowInfo) {
// record variable initialization if any
if (flowInfo.isReachable()) {
bits |= IsLocalDeclarationReachableMASK; // only set if actually reached
}
if (initialization == null)
return flowInfo;
flowInfo =
initialization
.analyseCode(currentScope, flowContext, flowInfo)
.unconditionalInits();
// final int i = (i = 0);
// no need to complain since (i = 0) part will get the blame
//if (binding.isFinal() && flowInfo.isPotentiallyAssigned(binding)) {
// currentScope.problemReporter().duplicateInitializationOfFinalLocal(binding, this);
//}
flowInfo.markAsDefinitelyAssigned(binding);
return flowInfo;
}
public void checkModifiers() {
//only potential valid modifier is <<final>>
if (((modifiers & AccJustFlag) & ~AccFinal) != 0)
//AccModifierProblem -> other (non-visibility problem)
//AccAlternateModifierProblem -> duplicate modifier
//AccModifierProblem | AccAlternateModifierProblem -> visibility problem"
modifiers = (modifiers & ~AccAlternateModifierProblem) | AccModifierProblem;
}
/**
* Code generation for a local declaration:
* i.e. normal assignment to a local variable + unused variable handling
*/
public void generateCode(BlockScope currentScope, CodeStream codeStream) {
// even if not reachable, variable must be added to visible if allocated (28298)
if (binding.resolvedPosition != -1) {
codeStream.addVisibleLocalVariable(binding);
}
if ((bits & IsReachableMASK) == 0) {
return;
}
int pc = codeStream.position;
Constant inlinedValue;
// something to initialize?
if (initialization != null) {
// initialize to constant value?
if ((inlinedValue = initialization.constant) != NotAConstant) {
// forget initializing unused or final locals set to constant value (final ones are inlined)
if (binding.resolvedPosition != -1) { // may need to preserve variable
int initPC = codeStream.position;
codeStream.generateConstant(inlinedValue, initialization.implicitConversion);
codeStream.recordPositionsFrom(initPC, initialization.sourceStart);
codeStream.store(binding, false);
binding.recordInitializationStartPC(codeStream.position);
// codeStream.lastInitStateIndexWhenRemovingInits = -2; // reinitialize remove index
// codeStream.lastInitStateIndexWhenAddingInits = -2; // reinitialize add index
}
} else { // initializing to non-constant value
initialization.generateCode(currentScope, codeStream, true);
// if binding unused generate then discard the value
if (binding.resolvedPosition != -1) {
// 26903, need extra cast to store null in array local var
if (binding.type.isArrayType()
&& (initialization.resolvedType == NullBinding // arrayLoc = null
|| ((initialization instanceof CastExpression) // arrayLoc = (type[])null
&& (((CastExpression)initialization).innermostCastedExpression().resolvedType == NullBinding)))){
codeStream.checkcast(binding.type);
}
codeStream.store(binding, false);
if (binding.initializationCount == 0) {
/* Variable may have been initialized during the code initializing it
e.g. int i = (i = 1);
*/
binding.recordInitializationStartPC(codeStream.position);
// codeStream.lastInitStateIndexWhenRemovingInits = -2; // reinitialize remove index
// codeStream.lastInitStateIndexWhenAddingInits = -2; // reinitialize add index
}
} else {
if ((binding.type == LongBinding) || (binding.type == DoubleBinding)) {
codeStream.pop2();
} else {
codeStream.pop();
}
}
}
}
codeStream.recordPositionsFrom(pc, this.sourceStart);
}
public void resolve(BlockScope scope) {
// create a binding and add it to the scope
TypeBinding typeBinding = type.resolveType(scope);
checkModifiers();
if (typeBinding != null) {
if (typeBinding == VoidBinding) {
scope.problemReporter().variableTypeCannotBeVoid(this);
return;
}
if (typeBinding.isArrayType() && ((ArrayBinding) typeBinding).leafComponentType == VoidBinding) {
scope.problemReporter().variableTypeCannotBeVoidArray(this);
return;
}
}
Binding existingVariable = scope.getBinding(name, BindingIds.VARIABLE, this, false /*do not resolve hidden field*/);
boolean shouldInsertInScope = true;
if (existingVariable != null && existingVariable.isValidBinding()){
if (existingVariable instanceof LocalVariableBinding && this.hiddenVariableDepth == 0) {
shouldInsertInScope = false;
scope.problemReporter().redefineLocal(this);
} else {
scope.problemReporter().localVariableHiding(this, existingVariable, false);
}
}
if (shouldInsertInScope) {
if ((modifiers & AccFinal)!= 0 && this.initialization == null) {
modifiers |= AccBlankFinal;
}
binding = new LocalVariableBinding(this, typeBinding, modifiers, false);
scope.addLocalVariable(binding);
binding.constant = NotAConstant;
// allow to recursivelly target the binding....
// the correct constant is harmed if correctly computed at the end of this method
}
if (typeBinding == null) {
if (initialization != null)
initialization.resolveType(scope); // want to report all possible errors
return;
}
// store the constant for final locals
if (initialization != null) {
if (initialization instanceof ArrayInitializer) {
TypeBinding initializationType = initialization.resolveTypeExpecting(scope, typeBinding);
if (initializationType != null) {
((ArrayInitializer) initialization).binding = (ArrayBinding) initializationType;
initialization.implicitWidening(typeBinding, initializationType);
}
} else {
TypeBinding initializationType = initialization.resolveType(scope);
if (initializationType != null) {
if (initialization.isConstantValueOfTypeAssignableToType(initializationType, typeBinding)
|| (typeBinding.isBaseType() && BaseTypeBinding.isWidening(typeBinding.id, initializationType.id))
|| initializationType.isCompatibleWith(typeBinding))
initialization.implicitWidening(typeBinding, initializationType);
else
scope.problemReporter().typeMismatchError(initializationType, typeBinding, this);
}
}
// change the constant in the binding when it is final
// (the optimization of the constant propagation will be done later on)
// cast from constant actual type to variable type
if (binding != null) {
binding.constant =
binding.isFinal()
? initialization.constant.castTo((typeBinding.id << 4) + initialization.constant.typeID())
: NotAConstant;
}
}
}
public void traverse(ASTVisitor visitor, BlockScope scope) {
if (visitor.visit(this, scope)) {
type.traverse(visitor, scope);
if (initialization != null)
initialization.traverse(visitor, scope);
}
visitor.endVisit(this, scope);
}
}
|
