public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) { return ReflectionMethodResolutionLogic.solveMethod(name, parameterTypes, staticOnly, typeSolver,this, clazz); }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> parameterTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues) { Optional<MethodUsage> res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) {
if (method.getName().equals(name) && !method.isBridge() && !method.isSynthetic()) { ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); MethodUsage methodUsage = replaceParams(typeParameterValues, scopeType, methodDeclaration); methods.add(methodUsage); if (ref.isSolved()){ ResolvedMethodDeclaration correspondingDeclaration = ref.getCorrespondingDeclaration(); MethodUsage methodUsage = replaceParams(typeParameterValues, ancestor.getTypeDeclaration(), correspondingDeclaration); methods.add(methodUsage); SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(objectClass.getTypeDeclaration(), name, argumentsTypes, typeSolver); if (ref.isSolved()) { MethodUsage usage = replaceParams(typeParameterValues, objectClass.getTypeDeclaration(), ref.getCorrespondingDeclaration()); methods.add(usage);
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> parameterTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues) { Optional<MethodUsage> res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) { // We have to replace method type typeParametersValues here InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE); MethodUsage methodUsage = res.get(); int i = 0; List<ResolvedType> parameters = new LinkedList<>(); for (ResolvedType actualType : parameterTypes) { ResolvedType formalType = methodUsage.getParamType(i); // We need to replace the class type typeParametersValues (while we derive the method ones) parameters.add(inferenceContext.addPair(formalType, actualType)); i++; } try { ResolvedType returnType = inferenceContext.addSingle(methodUsage.returnType()); for (int j=0;j<parameters.size();j++) { methodUsage = methodUsage.replaceParamType(j, inferenceContext.resolve(parameters.get(j))); } methodUsage = methodUsage.replaceReturnType(inferenceContext.resolve(returnType)); return Optional.of(methodUsage); } catch (ConfilictingGenericTypesException e) { return Optional.empty(); } } else { return res; } }
if (method.getName().equals(name) && !method.isBridge() && !method.isSynthetic()) { ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); MethodUsage methodUsage = replaceParams(typeParameterValues, scopeType, methodDeclaration); methods.add(methodUsage); if (ref.isSolved()){ ResolvedMethodDeclaration correspondingDeclaration = ref.getCorrespondingDeclaration(); MethodUsage methodUsage = replaceParams(typeParameterValues, ancestor.getTypeDeclaration(), correspondingDeclaration); methods.add(methodUsage); SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(objectClass.getTypeDeclaration(), name, argumentsTypes); if (ref.isSolved()) { MethodUsage usage = replaceParams(typeParameterValues, objectClass.getTypeDeclaration(), ref.getCorrespondingDeclaration()); methods.add(usage);
@Override public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) { return ReflectionMethodResolutionLogic.solveMethod(name, parameterTypes, staticOnly, typeSolver,this, clazz); }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> parameterTypes, Context invokationContext, List<ResolvedType> typeParameterValues) { Optional<MethodUsage> res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) {
if (method.getName().equals(name) && !method.isBridge() && !method.isSynthetic()) { ResolvedMethodDeclaration methodDeclaration = new ReflectionMethodDeclaration(method, typeSolver); MethodUsage methodUsage = replaceParams(typeParameterValues, scopeType, methodDeclaration); methods.add(methodUsage); if (ref.isSolved()){ ResolvedMethodDeclaration correspondingDeclaration = ref.getCorrespondingDeclaration(); MethodUsage methodUsage = replaceParams(typeParameterValues, ancestor.getTypeDeclaration(), correspondingDeclaration); methods.add(methodUsage); SymbolReference<ResolvedMethodDeclaration> ref = MethodResolutionLogic.solveMethodInType(objectClass.getTypeDeclaration(), name, argumentsTypes, typeSolver); if (ref.isSolved()) { MethodUsage usage = replaceParams(typeParameterValues, objectClass.getTypeDeclaration(), ref.getCorrespondingDeclaration()); methods.add(usage);
public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) { return ReflectionMethodResolutionLogic.solveMethod(name, parameterTypes, staticOnly, typeSolver,this, clazz); }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> parameterTypes, Context invokationContext, List<ResolvedType> typeParameterValues) { Optional<MethodUsage> res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) { // We have to replace method type typeParametersValues here InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE); MethodUsage methodUsage = res.get(); int i = 0; List<ResolvedType> parameters = new LinkedList<>(); for (ResolvedType actualType : parameterTypes) { ResolvedType formalType = methodUsage.getParamType(i); // We need to replace the class type typeParametersValues (while we derive the method ones) parameters.add(inferenceContext.addPair(formalType, actualType)); i++; } try { ResolvedType returnType = inferenceContext.addSingle(methodUsage.returnType()); for (int j=0;j<parameters.size();j++) { methodUsage = methodUsage.replaceParamType(j, inferenceContext.resolve(parameters.get(j))); } methodUsage = methodUsage.replaceReturnType(inferenceContext.resolve(returnType)); return Optional.of(methodUsage); } catch (ConfilictingGenericTypesException e) { return Optional.empty(); } } else { return res; } }
@Override @Deprecated public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) { return ReflectionMethodResolutionLogic.solveMethod(name, parameterTypes, staticOnly, typeSolver,this, clazz); }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> parameterTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues) { Optional<MethodUsage> res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) {
@Deprecated public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) { return ReflectionMethodResolutionLogic.solveMethod(name, parameterTypes, staticOnly, typeSolver,this, clazz); }
public Optional<MethodUsage> solveMethodAsUsage(String name, List<ResolvedType> parameterTypes, TypeSolver typeSolver, Context invokationContext, List<ResolvedType> typeParameterValues) { Optional<MethodUsage> res = ReflectionMethodResolutionLogic.solveMethodAsUsage(name, parameterTypes, typeSolver, invokationContext, typeParameterValues, this, clazz); if (res.isPresent()) { // We have to replace method type typeParametersValues here InferenceContext inferenceContext = new InferenceContext(MyObjectProvider.INSTANCE); MethodUsage methodUsage = res.get(); int i = 0; List<ResolvedType> parameters = new LinkedList<>(); for (ResolvedType actualType : parameterTypes) { ResolvedType formalType = methodUsage.getParamType(i); // We need to replace the class type typeParametersValues (while we derive the method ones) parameters.add(inferenceContext.addPair(formalType, actualType)); i++; } try { ResolvedType returnType = inferenceContext.addSingle(methodUsage.returnType()); for (int j=0;j<parameters.size();j++) { methodUsage = methodUsage.replaceParamType(j, inferenceContext.resolve(parameters.get(j))); } methodUsage = methodUsage.replaceReturnType(inferenceContext.resolve(returnType)); return Optional.of(methodUsage); } catch (ConfilictingGenericTypesException e) { return Optional.empty(); } } else { return res; } }
@Deprecated public SymbolReference<ResolvedMethodDeclaration> solveMethod(String name, List<ResolvedType> parameterTypes, boolean staticOnly) { return ReflectionMethodResolutionLogic.solveMethod(name, parameterTypes, staticOnly, typeSolver,this, clazz); }