// =========================================================================== // java_equivalence.cpp -- Names and normalization for Java equivalence model. // =========================================================================== #include "java_equivalence.h" #include namespace sleela { std::string JavaTypeDescriptor::normalized() const { std::ostringstream out; if (primitive) { switch (primitiveType) { case JavaPrimitiveType::Boolean: out<<"boolean"; break; case JavaPrimitiveType::Byte: out<<"byte"; break; case JavaPrimitiveType::Short: out<<"short"; break; case JavaPrimitiveType::Int: out<<"int"; break; case JavaPrimitiveType::Long: out<<"long"; break; case JavaPrimitiveType::Char: out<<"char"; break; case JavaPrimitiveType::Float: out<<"float"; break; case JavaPrimitiveType::Double: out<<"double"; break; case JavaPrimitiveType::Void: out<<"void"; break; } } else { if (referenceKind==JavaReferenceKind::Wildcard) out<<"?"; else out<"; } } for(int i=0;i=br?a.primitiveType:b.primitiveType);} return a; } static bool applicablePhase(const JavaMethodCandidate& m,const std::vector& a,JavaApplicabilityPhase p){ if(m.method.parameterTypes.size()!=a.size() && !(m.isVarargs&&p==JavaApplicabilityPhase::VariableArity)) return false; std::size_t n=m.method.parameterTypes.size(); for(std::size_t i=0;i=n-1)?n-1:i;if(pi>=n)return false; auto ctx=(p==JavaApplicabilityPhase::Strict)?JavaConversionContext::StrictInvocation: (p==JavaApplicabilityPhase::Loose)?JavaConversionContext::LooseInvocation:JavaConversionContext::LooseInvocation; if(!classifyJavaConversion(a[i],m.method.parameterTypes[pi],ctx).permitted)return false; } return true; } JavaMethodResolution resolveOverload(const std::vector& c,const std::vector& a,JavaApplicabilityPhase p){ JavaMethodResolution r;r.phase=p; for(std::size_t i=0;i& args){ JavaGenericInferenceResult r; if(c.method.typeParameters.empty()){r.success=true;return r;} if(c.method.parameterTypes.size()!=args.size() && !c.isVarargs){r.diagnostics.push_back("arity does not permit generic inference");return r;} for(std::size_t i=0;isecond.normalized()!=args[i].normalized()) r.diagnostics.push_back("conflicting inferred type for "+p.qualifiedName); } } r.success=r.diagnostics.empty(); if(r.success && r.inferred.size()&){ JavaMostSpecificResult r; if(a.method.parameterTypes.size()!=b.method.parameterTypes.size()){r.ambiguous=true;r.reason="different arity cannot establish specificity";return r;} bool ab=true,ba=true; for(std::size_t i=0;i(derivedAccess)>static_cast(baseAccess)) return false; if(!checkedExceptionsCompatible(base,derived)) return false; if(base.returnType.empty()||derived.returnType.empty()) return true; if(base.returnType==derived.returnType) return true; JavaTypeDescriptor b; b.qualifiedName=base.returnType; b.referenceKind=JavaReferenceKind::Class; JavaTypeDescriptor d; d.qualifiedName=derived.returnType; d.referenceKind=JavaReferenceKind::Class; return refSubtype(d,b); } bool variableArityApplicable(const JavaMethodCandidate& c,const std::vector& args){ if(!c.isVarargs||c.method.parameterTypes.empty()) return false; const std::size_t fixed=c.method.parameterTypes.size()-1; if(args.size()& c,const std::vector& applicable,const std::vector& args){ JavaMostSpecificSetResult r; for(int i:applicable){ bool maximal=true; for(int j:applicable) if(i!=j){ auto cmp=compareMostSpecific(c[j],c[i],args); if(cmp.firstMoreSpecific){maximal=false;break;} } if(maximal) r.maximallySpecific.push_back(i); } if(r.maximallySpecific.size()==1){r.selectedIndex=r.maximallySpecific[0];return r;} if(r.maximallySpecific.empty()){r.ambiguous=true;r.diagnostics.push_back("no maximally specific method");return r;} bool sameSig=true; for(std::size_t k=1;k=0){r.selectedIndex=concrete;return r;} int preferred=-1; for(int i:r.maximallySpecific){ bool preferredHere=true; for(int j:r.maximallySpecific) if(i!=j && !c[i].method.returnType.empty() && c[i].method.returnType!=c[j].method.returnType){ JavaTypeDescriptor a;a.qualifiedName=c[i].method.returnType; JavaTypeDescriptor b;b.qualifiedName=c[j].method.returnType; if(!refSubtype(a,b)) preferredHere=false; } if(preferredHere){if(preferred!=-1){preferred=-2;break;}preferred=i;} } if(preferred>=0){r.selectedIndex=preferred;return r;} } r.ambiguous=true;r.diagnostics.push_back("multiple maximally specific methods remain"); return r; } JavaInvocationTypeResult inferInvocationType(const JavaMethodCandidate& c,const std::vector& args,const JavaTypeDescriptor* target){ JavaInvocationTypeResult r; auto inf=inferGenericMethodTypes(c,args); r.inferred=inf.inferred; if(!inf.success){r.diagnostics=inf.diagnostics;return r;} r.invocationType=c.method; auto substitute=[&](const std::string& n){ auto it=r.inferred.find(n);return it==r.inferred.end()?std::string():it->second.normalized(); }; for(auto& p:r.invocationType.parameterTypes) if(p.referenceKind==JavaReferenceKind::TypeVariable){auto x=substitute(p.qualifiedName);if(!x.empty()){p.qualifiedName=x;p.referenceKind=JavaReferenceKind::Class;}} if(r.invocationType.returnType.size() && r.inferred.count(r.invocationType.returnType)) r.invocationType.returnType=r.inferred[r.invocationType.returnType].normalized(); if(target && !r.invocationType.returnType.empty()){ JavaTypeDescriptor actual;actual.qualifiedName=r.invocationType.returnType; auto conv=classifyJavaConversion(actual,*target,JavaConversionContext::Assignment); if(!conv.permitted){r.diagnostics.push_back("inferred invocation type is incompatible with target type");return r;} } r.success=true;return r; } JavaInterfaceInheritanceResult resolveInterfaceDefaults(const std::vector& methods){ JavaInterfaceInheritanceResult r; for(std::size_t i=0;i