2242 }
2243
2244 boolean needsVarArgsConversion() {
2245 return tree.varargsElement != null;
2246 }
2247
2248 /**
2249 * @return Is this an array operation like clone()
2250 */
2251 boolean isArrayOp() {
2252 return tree.sym.owner == syms.arrayClass;
2253 }
2254
2255 boolean receiverAccessible() {
2256 //hack needed to workaround 292 bug (7087658)
2257 //when 292 issue is fixed we should remove this and change the backend
2258 //code to always generate a method handle to an accessible method
2259 return tree.ownerAccessible;
2260 }
2261
2262 /**
2263 * This method should be called only when target release <= 14
2264 * where LambdaMetaFactory does not spin nestmate classes.
2265 *
2266 * This method should be removed when --release 14 is not supported.
2267 */
2268 boolean isPrivateInOtherClass() {
2269 assert !nestmateLambdas;
2270 return (tree.sym.flags() & PRIVATE) != 0 &&
2271 !types.isSameType(
2272 types.erasure(tree.sym.enclClass().asType()),
2273 types.erasure(owner.enclClass().asType()));
2274 }
2275
2276 /**
2277 * Erasure destroys the implementation parameter subtype
2278 * relationship for intersection types.
2279 * Have similar problems for union types too.
2280 */
2281 boolean interfaceParameterIsIntersectionOrUnionType() {
2294 return true;
2295 case TYPEVAR:
2296 TypeVar tv = (TypeVar) t;
2297 return isIntersectionOrUnionType(tv.getUpperBound());
2298 }
2299 return false;
2300 }
2301
2302 /**
2303 * Does this reference need to be converted to a lambda
2304 * (i.e. var args need to be expanded or "super" is used)
2305 */
2306 final boolean needsConversionToLambda() {
2307 return interfaceParameterIsIntersectionOrUnionType() ||
2308 isSuper ||
2309 needsVarArgsConversion() ||
2310 isArrayOp() ||
2311 (!nestmateLambdas && isPrivateInOtherClass()) ||
2312 isProtectedInSuperClassOfEnclosingClassInOtherPackage(tree.sym, owner) ||
2313 !receiverAccessible() ||
2314 (tree.getMode() == ReferenceMode.NEW &&
2315 tree.kind != ReferenceKind.ARRAY_CTOR &&
2316 (tree.sym.owner.isLocal() || tree.sym.owner.isInner()));
2317 }
2318
2319 Type generatedRefSig() {
2320 return types.erasure(tree.sym.type);
2321 }
2322
2323 Type bridgedRefSig() {
2324 return types.erasure(types.findDescriptorSymbol(tree.target.tsym).type);
2325 }
2326 }
2327 }
2328 // </editor-fold>
2329
2330 /*
2331 * These keys provide mappings for various translated lambda symbols
2332 * and the prevailing order must be maintained.
2333 */
2334 enum LambdaSymbolKind {
2335 PARAM, // original to translated lambda parameters
2336 LOCAL_VAR, // original to translated lambda locals
|
2242 }
2243
2244 boolean needsVarArgsConversion() {
2245 return tree.varargsElement != null;
2246 }
2247
2248 /**
2249 * @return Is this an array operation like clone()
2250 */
2251 boolean isArrayOp() {
2252 return tree.sym.owner == syms.arrayClass;
2253 }
2254
2255 boolean receiverAccessible() {
2256 //hack needed to workaround 292 bug (7087658)
2257 //when 292 issue is fixed we should remove this and change the backend
2258 //code to always generate a method handle to an accessible method
2259 return tree.ownerAccessible;
2260 }
2261
2262 /* Per our interim inline class translation scheme, the reference projection classes
2263 are completely empty, so we want the methods in the value class to be invoked instead.
2264 As the lambda meta factory isn't clued into this, it will try to invoke the method in
2265 C$ref.class and fail with a NoSuchMethodError. we need to workaround it ourselves.
2266 */
2267 boolean receiverIsReferenceProjection() {
2268 return tree.sym.kind == MTH && tree.sym.owner.isReferenceProjection();
2269 }
2270
2271 /**
2272 * This method should be called only when target release <= 14
2273 * where LambdaMetaFactory does not spin nestmate classes.
2274 *
2275 * This method should be removed when --release 14 is not supported.
2276 */
2277 boolean isPrivateInOtherClass() {
2278 assert !nestmateLambdas;
2279 return (tree.sym.flags() & PRIVATE) != 0 &&
2280 !types.isSameType(
2281 types.erasure(tree.sym.enclClass().asType()),
2282 types.erasure(owner.enclClass().asType()));
2283 }
2284
2285 /**
2286 * Erasure destroys the implementation parameter subtype
2287 * relationship for intersection types.
2288 * Have similar problems for union types too.
2289 */
2290 boolean interfaceParameterIsIntersectionOrUnionType() {
2303 return true;
2304 case TYPEVAR:
2305 TypeVar tv = (TypeVar) t;
2306 return isIntersectionOrUnionType(tv.getUpperBound());
2307 }
2308 return false;
2309 }
2310
2311 /**
2312 * Does this reference need to be converted to a lambda
2313 * (i.e. var args need to be expanded or "super" is used)
2314 */
2315 final boolean needsConversionToLambda() {
2316 return interfaceParameterIsIntersectionOrUnionType() ||
2317 isSuper ||
2318 needsVarArgsConversion() ||
2319 isArrayOp() ||
2320 (!nestmateLambdas && isPrivateInOtherClass()) ||
2321 isProtectedInSuperClassOfEnclosingClassInOtherPackage(tree.sym, owner) ||
2322 !receiverAccessible() ||
2323 receiverIsReferenceProjection() ||
2324 (tree.getMode() == ReferenceMode.NEW &&
2325 tree.kind != ReferenceKind.ARRAY_CTOR &&
2326 (tree.sym.owner.isLocal() || tree.sym.owner.isInner() || tree.sym.owner.isValue()));
2327 }
2328
2329 Type generatedRefSig() {
2330 return types.erasure(tree.sym.type);
2331 }
2332
2333 Type bridgedRefSig() {
2334 return types.erasure(types.findDescriptorSymbol(tree.target.tsym).type);
2335 }
2336 }
2337 }
2338 // </editor-fold>
2339
2340 /*
2341 * These keys provide mappings for various translated lambda symbols
2342 * and the prevailing order must be maintained.
2343 */
2344 enum LambdaSymbolKind {
2345 PARAM, // original to translated lambda parameters
2346 LOCAL_VAR, // original to translated lambda locals
|