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
|
/*******************************************************************************
* Copyright (c) 2000, 2021 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* This is an implementation of an early-draft specification developed under the Java
* Community Process (JCP) and is made available for testing and evaluation purposes
* only. The code is not compatible with any specification of the JCP.
*
* Contributors:
* IBM Corporation - initial API and implementation
* Stephan Herrmann - Contribution for
* bug 382350 - [1.8][compiler] Unable to invoke inherited default method via I.super.m() syntax
* bug 404649 - [1.8][compiler] detect illegal reference to indirect or redundant super
* Jesper S Moller <jesper@selskabet.org> - Contributions for
* bug 378674 - "The method can be declared as static" is wrong
*******************************************************************************/
package org.eclipse.jdt.internal.compiler.ast;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.*;
import org.eclipse.jdt.internal.compiler.flow.*;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.*;
public class QualifiedThisReference extends ThisReference {
public TypeReference qualification;
ReferenceBinding currentCompatibleType;
public QualifiedThisReference(TypeReference name, int sourceStart, int sourceEnd) {
super(sourceStart, sourceEnd);
this.qualification = name;
name.bits |= IgnoreRawTypeCheck; // no need to worry about raw type usage
this.sourceStart = name.sourceStart;
}
@Override
public FlowInfo analyseCode(
BlockScope currentScope,
FlowContext flowContext,
FlowInfo flowInfo) {
return flowInfo;
}
@Override
public FlowInfo analyseCode(
BlockScope currentScope,
FlowContext flowContext,
FlowInfo flowInfo,
boolean valueRequired) {
return flowInfo;
}
/**
* Code generation for QualifiedThisReference
*
* @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
* @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
* @param valueRequired boolean
*/
@Override
public void generateCode(
BlockScope currentScope,
CodeStream codeStream,
boolean valueRequired) {
int pc = codeStream.position;
if (valueRequired) {
if ((this.bits & DepthMASK) != 0) {
Object[] emulationPath =
currentScope.getEmulationPath(this.currentCompatibleType, true /*only exact match*/, false/*consider enclosing arg*/);
codeStream.generateOuterAccess(emulationPath, this, this.currentCompatibleType, currentScope);
} else {
// nothing particular after all
codeStream.aload_0();
}
}
codeStream.recordPositionsFrom(pc, this.sourceStart);
}
@Override
public TypeBinding resolveType(BlockScope scope) {
this.constant = Constant.NotAConstant;
// X.this is not a param/raw type as denoting enclosing instance
TypeBinding type = this.qualification.resolveType(scope, true /* check bounds*/);
if (type == null || !type.isValidBinding()) return null;
// X.this is not a param/raw type as denoting enclosing instance
type = type.erasure();
// resolvedType needs to be converted to parameterized
if (type instanceof ReferenceBinding) {
this.resolvedType = scope.environment().convertToParameterizedType((ReferenceBinding) type);
} else {
// error case
this.resolvedType = type;
}
// the qualification MUST exactly match some enclosing type name
// It is possible to qualify 'this' by the name of the current class
int depth = findCompatibleEnclosing(scope.referenceType().binding, type, scope);
this.bits &= ~DepthMASK; // flush previous depth if any
this.bits |= (depth & 0xFF) << DepthSHIFT; // encoded depth into 8 bits
if (this.currentCompatibleType == null) {
if (this.resolvedType.isValidBinding())
scope.problemReporter().noSuchEnclosingInstance(type, this, false);
// otherwise problem will be reported by the caller
return this.resolvedType;
} else {
scope.tagAsAccessingEnclosingInstanceStateOf(this.currentCompatibleType, false /* type variable access */);
}
// Ensure one cannot write code like: B() { super(B.this); }
if (depth == 0) {
checkAccess(scope, null);
} // if depth>0, path emulation will diagnose bad scenarii
else if (scope.compilerOptions().complianceLevel >= ClassFileConstants.JDK16) {
MethodScope ms = scope.methodScope();
if (ms.isStatic)
ms.problemReporter().errorThisSuperInStatic(this);
}
MethodScope methodScope = scope.namedMethodScope();
if (methodScope != null) {
MethodBinding method = methodScope.referenceMethodBinding();
if (method != null) {
TypeBinding receiver = method.receiver;
while (receiver != null) {
if (TypeBinding.equalsEquals(receiver, this.resolvedType))
return this.resolvedType = receiver;
receiver = receiver.enclosingType();
}
}
}
return this.resolvedType;
}
int findCompatibleEnclosing(ReferenceBinding enclosingType, TypeBinding type, BlockScope scope) {
int depth = 0;
this.currentCompatibleType = enclosingType;
while (this.currentCompatibleType != null && TypeBinding.notEquals(this.currentCompatibleType, type)) {
depth++;
this.currentCompatibleType = this.currentCompatibleType.isStatic() ? null : this.currentCompatibleType.enclosingType();
}
return depth;
}
@Override
public StringBuffer printExpression(int indent, StringBuffer output) {
return this.qualification.print(0, output).append(".this"); //$NON-NLS-1$
}
@Override
public void traverse(
ASTVisitor visitor,
BlockScope blockScope) {
if (visitor.visit(this, blockScope)) {
this.qualification.traverse(visitor, blockScope);
}
visitor.endVisit(this, blockScope);
}
@Override
public void traverse(
ASTVisitor visitor,
ClassScope blockScope) {
if (visitor.visit(this, blockScope)) {
this.qualification.traverse(visitor, blockScope);
}
visitor.endVisit(this, blockScope);
}
}
|
