2236 }
2237
2238 boolean needsVarArgsConversion() {
2239 return tree.varargsElement != null;
2240 }
2241
2242 /**
2243 * @return Is this an array operation like clone()
2244 */
2245 boolean isArrayOp() {
2246 return tree.sym.owner == syms.arrayClass;
2247 }
2248
2249 boolean receiverAccessible() {
2250 //hack needed to workaround 292 bug (7087658)
2251 //when 292 issue is fixed we should remove this and change the backend
2252 //code to always generate a method handle to an accessible method
2253 return tree.ownerAccessible;
2254 }
2255
2256 /**
2257 * The VM does not support access across nested classes (8010319).
2258 * Were that ever to change, this should be removed.
2259 */
2260 boolean isPrivateInOtherClass() {
2261 return (tree.sym.flags() & PRIVATE) != 0 &&
2262 !types.isSameType(
2263 types.erasure(tree.sym.enclClass().asType()),
2264 types.erasure(owner.enclClass().asType()));
2265 }
2266
2267 boolean isProtectedInSuperClassOfEnclosingClassInOtherPackage() {
2268 return ((tree.sym.flags() & PROTECTED) != 0 &&
2269 tree.sym.packge() != owner.packge() &&
2270 !owner.enclClass().isSubClass(tree.sym.owner, types));
2271 }
2272
2273 /**
2274 * Erasure destroys the implementation parameter subtype
2275 * relationship for intersection types.
2276 * Have similar problems for union types too.
2277 */
2278 boolean interfaceParameterIsIntersectionOrUnionType() {
2279 List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
2280 for (; tl.nonEmpty(); tl = tl.tail) {
2281 Type pt = tl.head;
2282 return isIntersectionOrUnionType(pt);
2283 }
2284 return false;
2285 }
2286
2287 boolean isIntersectionOrUnionType(Type t) {
2288 switch (t.getKind()) {
2289 case INTERSECTION:
2290 case UNION:
2291 return true;
2292 case TYPEVAR:
2293 TypeVar tv = (TypeVar) t;
2294 return isIntersectionOrUnionType(tv.getUpperBound());
2295 }
2296 return false;
2297 }
2298
2299 /**
2300 * Does this reference need to be converted to a lambda
2301 * (i.e. var args need to be expanded or "super" is used)
2302 */
2303 final boolean needsConversionToLambda() {
2304 return interfaceParameterIsIntersectionOrUnionType() ||
2305 isSuper ||
2306 needsVarArgsConversion() ||
2307 isArrayOp() ||
2308 isPrivateInOtherClass() ||
2309 isProtectedInSuperClassOfEnclosingClassInOtherPackage() ||
2310 !receiverAccessible() ||
2311 (tree.getMode() == ReferenceMode.NEW &&
2312 tree.kind != ReferenceKind.ARRAY_CTOR &&
2313 (tree.sym.owner.isLocal() || tree.sym.owner.isInner()));
2314 }
2315
2316 Type generatedRefSig() {
2317 return types.erasure(tree.sym.type);
2318 }
2319
2320 Type bridgedRefSig() {
2321 return types.erasure(types.findDescriptorSymbol(tree.target.tsym).type);
2322 }
2323 }
2324 }
2325 // </editor-fold>
2326
2327 /*
2328 * These keys provide mappings for various translated lambda symbols
|
2236 }
2237
2238 boolean needsVarArgsConversion() {
2239 return tree.varargsElement != null;
2240 }
2241
2242 /**
2243 * @return Is this an array operation like clone()
2244 */
2245 boolean isArrayOp() {
2246 return tree.sym.owner == syms.arrayClass;
2247 }
2248
2249 boolean receiverAccessible() {
2250 //hack needed to workaround 292 bug (7087658)
2251 //when 292 issue is fixed we should remove this and change the backend
2252 //code to always generate a method handle to an accessible method
2253 return tree.ownerAccessible;
2254 }
2255
2256 boolean isProtectedInSuperClassOfEnclosingClassInOtherPackage() {
2257 return ((tree.sym.flags() & PROTECTED) != 0 &&
2258 tree.sym.packge() != owner.packge());
2259 }
2260
2261 /**
2262 * Erasure destroys the implementation parameter subtype
2263 * relationship for intersection types.
2264 * Have similar problems for union types too.
2265 */
2266 boolean interfaceParameterIsIntersectionOrUnionType() {
2267 List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
2268 for (; tl.nonEmpty(); tl = tl.tail) {
2269 Type pt = tl.head;
2270 return isIntersectionOrUnionType(pt);
2271 }
2272 return false;
2273 }
2274
2275 boolean isIntersectionOrUnionType(Type t) {
2276 switch (t.getKind()) {
2277 case INTERSECTION:
2278 case UNION:
2279 return true;
2280 case TYPEVAR:
2281 TypeVar tv = (TypeVar) t;
2282 return isIntersectionOrUnionType(tv.getUpperBound());
2283 }
2284 return false;
2285 }
2286
2287 /**
2288 * Does this reference need to be converted to a lambda
2289 * (i.e. var args need to be expanded or "super" is used)
2290 */
2291 final boolean needsConversionToLambda() {
2292 return interfaceParameterIsIntersectionOrUnionType() ||
2293 isSuper ||
2294 needsVarArgsConversion() ||
2295 isArrayOp() ||
2296 isProtectedInSuperClassOfEnclosingClassInOtherPackage() ||
2297 !receiverAccessible() ||
2298 (tree.getMode() == ReferenceMode.NEW &&
2299 tree.kind != ReferenceKind.ARRAY_CTOR &&
2300 (tree.sym.owner.isLocal() || tree.sym.owner.isInner()));
2301 }
2302
2303 Type generatedRefSig() {
2304 return types.erasure(tree.sym.type);
2305 }
2306
2307 Type bridgedRefSig() {
2308 return types.erasure(types.findDescriptorSymbol(tree.target.tsym).type);
2309 }
2310 }
2311 }
2312 // </editor-fold>
2313
2314 /*
2315 * These keys provide mappings for various translated lambda symbols
|