public boolean isCalculated() { switch (kind) { case TYPE: return getTypeSignature().isCalculated(); case NAMED_TYPE: return getNamedTypeSignature().getTypeSignature().isCalculated(); case LONG: return false; case VARIABLE: return true; default: throw new IllegalArgumentException("Unexpected parameter kind: " + kind); } }
@Test public void testIsCalculated() { assertFalse(parseTypeSignature("bigint").isCalculated()); assertTrue(parseTypeSignature("decimal(p, s)", ImmutableSet.of("p", "s")).isCalculated()); assertFalse(parseTypeSignature("decimal(2, 1)").isCalculated()); assertTrue(parseTypeSignature("array(decimal(p, s))", ImmutableSet.of("p", "s")).isCalculated()); assertFalse(parseTypeSignature("array(decimal(2, 1))").isCalculated()); assertTrue(parseTypeSignature("map(decimal(p1, s1),decimal(p2, s2))", ImmutableSet.of("p1", "s1", "p2", "s2")).isCalculated()); assertFalse(parseTypeSignature("map(decimal(2, 1),decimal(3, 1))").isCalculated()); assertTrue(parseTypeSignature("row(a decimal(p1,s1),b decimal(p2,s2))", ImmutableSet.of("p1", "s1", "p2", "s2")).isCalculated()); assertFalse(parseTypeSignature("row(a decimal(2,1),b decimal(3,2))").isCalculated()); }
public void addImplementation(T implementation) { if (implementation.getSignature().getTypeVariableConstraints().isEmpty() && implementation.getSignature().getArgumentTypes().stream().noneMatch(TypeSignature::isCalculated) && !implementation.getSignature().getReturnType().isCalculated()) { exactImplementations.put(implementation.getSignature(), implementation); } else if (implementation.hasSpecializedTypeParameters()) { specializedImplementations.add(implementation); } else { genericImplementations.add(implementation); } }
public boolean isCalculated() { switch (kind) { case TYPE: return getTypeSignature().isCalculated(); case NAMED_TYPE: return getNamedTypeSignature().getTypeSignature().isCalculated(); case LONG: return false; case VARIABLE: return true; default: throw new IllegalArgumentException("Unexpected parameter kind: " + kind); } }
public Signature resolveCalculatedTypes(List<TypeSignature> parameterTypes) { if (!returnType.isCalculated() && argumentTypes.stream().noneMatch(TypeSignature::isCalculated)) { return this; } Map<String, OptionalLong> inputs = new HashMap<>(); for (int index = 0; index < argumentTypes.size(); index++) { TypeSignature argument = argumentTypes.get(index); if (argument.isCalculated()) { TypeSignature actualParameter = parameterTypes.get(index); inputs.putAll(TypeUtils.computeParameterBindings(argument, actualParameter)); } } TypeSignature calculatedReturnType = TypeUtils.resolveCalculatedType(returnType, inputs, true); return new Signature( name, kind, calculatedReturnType, argumentTypes.stream().map(parameter -> TypeUtils.resolveCalculatedType(parameter, inputs, false)).collect(toImmutableList())); }
private static void verifyMethodSignature(Method method, TypeSignature returnTypeName, List<TypeSignature> argumentTypeNames, TypeManager typeManager) if (!returnTypeName.isCalculated()) { Type returnType = typeManager.getType(returnTypeName); requireNonNull(returnType, "returnType is null"); if (expectedTypeName.isCalculated()) { continue;
public static Map<String, OptionalLong> computeParameterBindings(TypeSignature declaredType, TypeSignature actualType) if (!declaredType.isCalculated()) { return emptyMap();