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 }
2271
2272 /**
2273 * Erasure destroys the implementation parameter subtype
2274 * relationship for intersection types.
2275 * Have similar problems for union types too.
2276 */
2277 boolean interfaceParameterIsIntersectionOrUnionType() {
2278 List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
2279 for (; tl.nonEmpty(); tl = tl.tail) {
2280 Type pt = tl.head;
2281 return isIntersectionOrUnionType(pt);
2282 }
2283 return false;
2284 }
2285
2286 boolean isIntersectionOrUnionType(Type t) {
2287 switch (t.getKind()) {
2288 case INTERSECTION:
2289 case UNION:
2290 return true;
2291 case TYPEVAR:
2292 TypeVar tv = (TypeVar) t;
2293 return isIntersectionOrUnionType(tv.getUpperBound());
2294 }
2295 return false;
2296 }
2297
2298 /**
2299 * Does this reference need to be converted to a lambda
2300 * (i.e. var args need to be expanded or "super" is used)
2301 */
2302 final boolean needsConversionToLambda() {
2303 return interfaceParameterIsIntersectionOrUnionType() ||
2304 isSuper ||
2305 needsVarArgsConversion() ||
2306 isArrayOp() ||
2307 isPrivateInOtherClass() ||
2308 isProtectedInSuperClassOfEnclosingClassInOtherPackage() ||
2309 !receiverAccessible() ||
2310 (tree.getMode() == ReferenceMode.NEW &&
2311 tree.kind != ReferenceKind.ARRAY_CTOR &&
2312 (tree.sym.owner.isLocal() || tree.sym.owner.isInner()));
2313 }
2314
2315 Type generatedRefSig() {
2316 return types.erasure(tree.sym.type);
2317 }
2318
2319 Type bridgedRefSig() {
2320 return types.erasure(types.findDescriptorSymbol(tree.target.tsym).type);
2321 }
2322 }
2323 }
2324 // </editor-fold>
2325
2326 /*
2327 * 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
|