Rename TypeParameter to TypeParameterRequirement

It more accurately describes a constraint that a type argument
needs to satisfy.

presto-main/src/main/java/com/facebook/presto/metadata/FunctionRegistry.java

@@ -453,7 +453,7 @@ public Signature resolveFunction(QualifiedName name, List<TypeSignature> paramet
             expectedParameters.add(format("%s(%s) %s",
                                     name,
                                     Joiner.on(", ").join(function.getSignature().getArgumentTypes()),
-                                    Joiner.on(", ").join(function.getSignature().getTypeParameters())));
+                                    Joiner.on(", ").join(function.getSignature().getTypeParameterRequirements())));
         }
         String parameters = Joiner.on(", ").join(parameterTypes);
         String message = format("Function %s not registered", name);
@@ -509,7 +509,7 @@ private SqlFunction getRowFieldReference(String field, TypeSignature rowTypeSign
     public WindowFunctionSupplier getWindowFunctionImplementation(Signature signature)
     {
         checkArgument(signature.getKind() == WINDOW || signature.getKind() == AGGREGATE, "%s is not a window function", signature);
-        checkArgument(signature.getTypeParameters().isEmpty(), "%s has unbound type parameters", signature);
+        checkArgument(signature.getTypeParameterRequirements().isEmpty(), "%s has unbound type parameters", signature);
         Iterable<SqlFunction> candidates = functions.get(QualifiedName.of(signature.getName()));
         // search for exact match
         for (SqlFunction operator : candidates) {
@@ -531,7 +531,7 @@ public WindowFunctionSupplier getWindowFunctionImplementation(Signature signatur
     public InternalAggregationFunction getAggregateFunctionImplementation(Signature signature)
     {
         checkArgument(signature.getKind() == AGGREGATE || signature.getKind() == APPROXIMATE_AGGREGATE, "%s is not an aggregate function", signature);
-        checkArgument(signature.getTypeParameters().isEmpty(), "%s has unbound type parameters", signature);
+        checkArgument(signature.getTypeParameterRequirements().isEmpty(), "%s has unbound type parameters", signature);
         Iterable<SqlFunction> candidates = functions.get(QualifiedName.of(signature.getName()));
         // search for exact match
         for (SqlFunction operator : candidates) {
@@ -553,7 +553,7 @@ public InternalAggregationFunction getAggregateFunctionImplementation(Signature
     public ScalarFunctionImplementation getScalarFunctionImplementation(Signature signature)
     {
         checkArgument(signature.getKind() == SCALAR, "%s is not a scalar function", signature);
-        checkArgument(signature.getTypeParameters().isEmpty(), "%s has unbound type parameters", signature);
+        checkArgument(signature.getTypeParameterRequirements().isEmpty(), "%s has unbound type parameters", signature);
         Iterable<SqlFunction> candidates = functions.get(QualifiedName.of(signature.getName()));
         // search for exact match
         Type returnType = typeManager.getType(signature.getReturnType());

presto-main/src/main/java/com/facebook/presto/metadata/Signature.java

@@ -45,7 +45,7 @@ public final class Signature
 {
     private final String name;
     private final FunctionKind kind;
-    private final List<TypeParameter> typeParameters;
+    private final List<TypeParameterRequirement> typeParameterRequirements;
     private final TypeSignature returnType;
     private final List<TypeSignature> argumentTypes;
     private final boolean variableArity;
@@ -54,30 +54,30 @@ public final class Signature
     public Signature(
             @JsonProperty("name") String name,
             @JsonProperty("kind") FunctionKind kind,
-            @JsonProperty("typeParameters") List<TypeParameter> typeParameters,
+            @JsonProperty("typeParameterRequirements") List<TypeParameterRequirement> typeParameterRequirements,
             @JsonProperty("returnType") TypeSignature returnType,
             @JsonProperty("argumentTypes") List<TypeSignature> argumentTypes,
             @JsonProperty("variableArity") boolean variableArity)
     {
         requireNonNull(name, "name is null");
-        requireNonNull(typeParameters, "typeParameters is null");
+        requireNonNull(typeParameterRequirements, "typeParameters is null");
 
         this.name = name;
         this.kind = requireNonNull(kind, "type is null");
-        this.typeParameters = ImmutableList.copyOf(typeParameters);
+        this.typeParameterRequirements = ImmutableList.copyOf(typeParameterRequirements);
         this.returnType = requireNonNull(returnType, "returnType is null");
         this.argumentTypes = ImmutableList.copyOf(requireNonNull(argumentTypes, "argumentTypes is null"));
         this.variableArity = variableArity;
     }
 
-    public Signature(String name, FunctionKind kind, List<TypeParameter> typeParameters, String returnType, List<String> argumentTypes, boolean variableArity)
+    public Signature(String name, FunctionKind kind, List<TypeParameterRequirement> typeParameterRequirements, String returnType, List<String> argumentTypes, boolean variableArity)
     {
-        this(name, kind, typeParameters, parseTypeSignature(returnType), Lists.transform(argumentTypes, TypeSignature::parseTypeSignature), variableArity);
+        this(name, kind, typeParameterRequirements, parseTypeSignature(returnType), Lists.transform(argumentTypes, TypeSignature::parseTypeSignature), variableArity);
     }
 
     public Signature(String name, FunctionKind kind, String returnType, List<String> argumentTypes)
     {
-        this(name, kind, ImmutableList.<TypeParameter>of(), parseTypeSignature(returnType), Lists.transform(argumentTypes, TypeSignature::parseTypeSignature), false);
+        this(name, kind, ImmutableList.<TypeParameterRequirement>of(), parseTypeSignature(returnType), Lists.transform(argumentTypes, TypeSignature::parseTypeSignature), false);
     }
 
     public Signature(String name, FunctionKind kind, String returnType, String... argumentTypes)
@@ -87,7 +87,7 @@ public Signature(String name, FunctionKind kind, String returnType, String... ar
 
     public Signature(String name, FunctionKind kind, TypeSignature returnType, List<TypeSignature> argumentTypes)
     {
-        this(name, kind, ImmutableList.<TypeParameter>of(), returnType, argumentTypes, false);
+        this(name, kind, ImmutableList.<TypeParameterRequirement>of(), returnType, argumentTypes, false);
     }
 
     public Signature(String name, FunctionKind kind, TypeSignature returnType, TypeSignature... argumentTypes)
@@ -117,7 +117,7 @@ public static Signature internalScalarFunction(String name, String returnType, S
 
     public static Signature internalScalarFunction(String name, String returnType, List<String> argumentTypes)
     {
-        return new Signature(name, SCALAR, ImmutableList.<TypeParameter>of(), returnType, argumentTypes, false);
+        return new Signature(name, SCALAR, ImmutableList.<TypeParameterRequirement>of(), returnType, argumentTypes, false);
     }
 
     public static Signature internalScalarFunction(String name, TypeSignature returnType, TypeSignature... argumentTypes)
@@ -127,7 +127,7 @@ public static Signature internalScalarFunction(String name, TypeSignature return
 
     public static Signature internalScalarFunction(String name, TypeSignature returnType, List<TypeSignature> argumentTypes)
     {
-        return new Signature(name, SCALAR, ImmutableList.<TypeParameter>of(), returnType, argumentTypes, false);
+        return new Signature(name, SCALAR, ImmutableList.<TypeParameterRequirement>of(), returnType, argumentTypes, false);
     }
 
     @JsonProperty
@@ -161,20 +161,20 @@ public boolean isVariableArity()
     }
 
     @JsonProperty
-    public List<TypeParameter> getTypeParameters()
+    public List<TypeParameterRequirement> getTypeParameterRequirements()
     {
-        return typeParameters;
+        return typeParameterRequirements;
     }
 
     @Override
     public int hashCode()
     {
-        return Objects.hash(name, kind, typeParameters, returnType, argumentTypes, variableArity);
+        return Objects.hash(name, kind, typeParameterRequirements, returnType, argumentTypes, variableArity);
     }
 
     Signature withAlias(String name)
     {
-        return new Signature(name, kind, typeParameters, getReturnType(), getArgumentTypes(), variableArity);
+        return new Signature(name, kind, typeParameterRequirements, getReturnType(), getArgumentTypes(), variableArity);
     }
 
     @Override
@@ -189,7 +189,7 @@ public boolean equals(Object obj)
         Signature other = (Signature) obj;
         return Objects.equals(this.name, other.name) &&
                 Objects.equals(this.kind, other.kind) &&
-                Objects.equals(this.typeParameters, other.typeParameters) &&
+                Objects.equals(this.typeParameterRequirements, other.typeParameterRequirements) &&
                 Objects.equals(this.returnType, other.returnType) &&
                 Objects.equals(this.argumentTypes, other.argumentTypes) &&
                 Objects.equals(this.variableArity, other.variableArity);
@@ -198,19 +198,19 @@ public boolean equals(Object obj)
     @Override
     public String toString()
     {
-        return name + (typeParameters.isEmpty() ? "" : "<" + Joiner.on(",").join(typeParameters) + ">") + "(" + Joiner.on(",").join(argumentTypes) + "):" + returnType;
+        return name + (typeParameterRequirements.isEmpty() ? "" : "<" + Joiner.on(",").join(typeParameterRequirements) + ">") + "(" + Joiner.on(",").join(argumentTypes) + "):" + returnType;
     }
 
     @Nullable
     public Map<String, Type> bindTypeParameters(Type returnType, List<? extends Type> types, boolean allowCoercion, TypeManager typeManager)
     {
         Map<String, Type> boundParameters = new HashMap<>();
-        ImmutableMap.Builder<String, TypeParameter> builder = ImmutableMap.builder();
-        for (TypeParameter parameter : typeParameters) {
+        ImmutableMap.Builder<String, TypeParameterRequirement> builder = ImmutableMap.builder();
+        for (TypeParameterRequirement parameter : typeParameterRequirements) {
             builder.put(parameter.getName(), parameter);
         }
 
-        ImmutableMap<String, TypeParameter> parameters = builder.build();
+        ImmutableMap<String, TypeParameterRequirement> parameters = builder.build();
         if (!matchAndBind(boundParameters, parameters, this.returnType, returnType, allowCoercion, typeManager)) {
             return null;
         }
@@ -232,12 +232,12 @@ public Map<String, Type> bindTypeParameters(Type returnType, List<? extends Type
     public Map<String, Type> bindTypeParameters(List<? extends Type> types, boolean allowCoercion, TypeManager typeManager)
     {
         Map<String, Type> boundParameters = new HashMap<>();
-        ImmutableMap.Builder<String, TypeParameter> builder = ImmutableMap.builder();
-        for (TypeParameter parameter : typeParameters) {
+        ImmutableMap.Builder<String, TypeParameterRequirement> builder = ImmutableMap.builder();
+        for (TypeParameterRequirement parameter : typeParameterRequirements) {
             builder.put(parameter.getName(), parameter);
         }
 
-        ImmutableMap<String, TypeParameter> parameters = builder.build();
+        ImmutableMap<String, TypeParameterRequirement> parameters = builder.build();
         if (!matchArguments(boundParameters, parameters, argumentTypes, types, allowCoercion, variableArity, typeManager)) {
             return null;
         }
@@ -249,7 +249,7 @@ public Map<String, Type> bindTypeParameters(List<? extends Type> types, boolean
 
     private static boolean matchArguments(
             Map<String, Type> boundParameters,
-            Map<String, TypeParameter> parameters,
+            Map<String, TypeParameterRequirement> parameters,
             List<TypeSignature> argumentTypes,
             List<? extends Type> types,
             boolean allowCoercion,
@@ -290,7 +290,7 @@ private static boolean matchArguments(
         return true;
     }
 
-    private static boolean matchAndBind(Map<String, Type> boundParameters, Map<String, TypeParameter> typeParameters, TypeSignature parameter, Type type, boolean allowCoercion, TypeManager typeManager)
+    private static boolean matchAndBind(Map<String, Type> boundParameters, Map<String, TypeParameterRequirement> typeParameters, TypeSignature parameter, Type type, boolean allowCoercion, TypeManager typeManager)
     {
         // TODO: add literals to Types and switch to TypeSignatureParameter so boundParameters map includes also literal parameter bindings
         List<TypeSignature> typeSignatures = parameter.getTypeParametersAsTypeSignatures();
@@ -329,8 +329,8 @@ else if (canCoerce(boundParameters.get(parameter.getBase()), type) && typeParame
 
         // Bind parameter, if this is a free type parameter
         if (typeParameters.containsKey(parameter.getBase())) {
-            TypeParameter typeParameter = typeParameters.get(parameter.getBase());
-            if (!typeParameter.canBind(type)) {
+            TypeParameterRequirement typeParameterRequirement = typeParameters.get(parameter.getBase());
+            if (!typeParameterRequirement.canBind(type)) {
                 return false;
             }
             boundParameters.put(parameter.getBase(), type);
@@ -354,28 +354,28 @@ else if (canCoerce(boundParameters.get(parameter.getBase()), type) && typeParame
     /*
      * similar to T extends MyClass<?...>, if Java supported varargs wildcards
      */
-    public static TypeParameter withVariadicBound(String name, String variadicBound)
+    public static TypeParameterRequirement withVariadicBound(String name, String variadicBound)
     {
-        return new TypeParameter(name, false, false, variadicBound);
+        return new TypeParameterRequirement(name, false, false, variadicBound);
     }
 
-    public static TypeParameter comparableWithVariadicBound(String name, String variadicBound)
+    public static TypeParameterRequirement comparableWithVariadicBound(String name, String variadicBound)
     {
-        return new TypeParameter(name, true, false, variadicBound);
+        return new TypeParameterRequirement(name, true, false, variadicBound);
     }
 
-    public static TypeParameter typeParameter(String name)
+    public static TypeParameterRequirement typeParameter(String name)
     {
-        return new TypeParameter(name, false, false, null);
+        return new TypeParameterRequirement(name, false, false, null);
     }
 
-    public static TypeParameter comparableTypeParameter(String name)
+    public static TypeParameterRequirement comparableTypeParameter(String name)
     {
-        return new TypeParameter(name, true, false, null);
+        return new TypeParameterRequirement(name, true, false, null);
     }
 
-    public static TypeParameter orderableTypeParameter(String name)
+    public static TypeParameterRequirement orderableTypeParameter(String name)
     {
-        return new TypeParameter(name, false, true, null);
+        return new TypeParameterRequirement(name, false, true, null);
     }
 }

presto-main/src/main/java/com/facebook/presto/metadata/SqlAggregationFunction.java

@@ -38,19 +38,19 @@ public static SqlAggregationFunction create(String name, String description, Int
         return new SimpleSqlAggregationFunction(name, description, function);
     }
 
-    protected SqlAggregationFunction(String name, List<TypeParameter> typeParameters, String returnType, List<String> argumentTypes)
+    protected SqlAggregationFunction(String name, List<TypeParameterRequirement> typeParameterRequirements, String returnType, List<String> argumentTypes)
     {
-        this(name, typeParameters, returnType, argumentTypes, AGGREGATE);
+        this(name, typeParameterRequirements, returnType, argumentTypes, AGGREGATE);
     }
 
-    protected SqlAggregationFunction(String name, List<TypeParameter> typeParameters, String returnType, List<String> argumentTypes, FunctionKind kind)
+    protected SqlAggregationFunction(String name, List<TypeParameterRequirement> typeParameterRequirements, String returnType, List<String> argumentTypes, FunctionKind kind)
     {
         requireNonNull(name, "name is null");
-        requireNonNull(typeParameters, "typeParameters is null");
+        requireNonNull(typeParameterRequirements, "typeParameters is null");
         requireNonNull(returnType, "returnType is null");
         requireNonNull(argumentTypes, "argumentTypes is null");
         checkArgument(kind == AGGREGATE || kind == APPROXIMATE_AGGREGATE, "kind must be an aggregate");
-        this.signature = new Signature(name, kind, ImmutableList.copyOf(typeParameters), returnType, ImmutableList.copyOf(argumentTypes), false);
+        this.signature = new Signature(name, kind, ImmutableList.copyOf(typeParameterRequirements), returnType, ImmutableList.copyOf(argumentTypes), false);
     }
 
     @Override
@@ -85,7 +85,7 @@ public SimpleSqlAggregationFunction(
                 InternalAggregationFunction function)
         {
             super(name,
-                    ImmutableList.<TypeParameter>of(),
+                    ImmutableList.<TypeParameterRequirement>of(),
                     function.getFinalType().getTypeSignature().toString(),
                     function.getParameterTypes().stream()
                             .map(Type::getTypeSignature)

presto-main/src/main/java/com/facebook/presto/metadata/SqlOperator.java

@@ -43,9 +43,9 @@ public static SqlOperator create(
         return new SimpleSqlOperator(operatorType, argumentTypes, returnType, methodHandle, instanceFactory, nullable, nullableArguments);
     }
 
-    protected SqlOperator(OperatorType operatorType, List<TypeParameter> typeParameters, String returnType, List<String> argumentTypes)
+    protected SqlOperator(OperatorType operatorType, List<TypeParameterRequirement> typeParameterRequirements, String returnType, List<String> argumentTypes)
     {
-        super(mangleOperatorName(operatorType), typeParameters, returnType, argumentTypes);
+        super(mangleOperatorName(operatorType), typeParameterRequirements, returnType, argumentTypes);
     }
 
     @Override

presto-main/src/main/java/com/facebook/presto/metadata/SqlScalarFunction.java

@@ -47,18 +47,18 @@ public static SqlScalarFunction create(
         return new SimpleSqlScalarFunction(signature, description, hidden, methodHandle, instanceFactory, deterministic, nullable, nullableArguments);
     }
 
-    protected SqlScalarFunction(String name, List<TypeParameter> typeParameters, String returnType, List<String> argumentTypes)
+    protected SqlScalarFunction(String name, List<TypeParameterRequirement> typeParameterRequirements, String returnType, List<String> argumentTypes)
     {
-        this(name, typeParameters, returnType, argumentTypes, false);
+        this(name, typeParameterRequirements, returnType, argumentTypes, false);
     }
 
-    protected SqlScalarFunction(String name, List<TypeParameter> typeParameters, String returnType, List<String> argumentTypes, boolean variableArity)
+    protected SqlScalarFunction(String name, List<TypeParameterRequirement> typeParameterRequirements, String returnType, List<String> argumentTypes, boolean variableArity)
     {
         requireNonNull(name, "name is null");
-        requireNonNull(typeParameters, "typeParameters is null");
+        requireNonNull(typeParameterRequirements, "typeParameters is null");
         requireNonNull(returnType, "returnType is null");
         requireNonNull(argumentTypes, "argumentTypes is null");
-        this.signature = new Signature(name, SCALAR, ImmutableList.copyOf(typeParameters), returnType, ImmutableList.copyOf(argumentTypes), variableArity);
+        this.signature = new Signature(name, SCALAR, ImmutableList.copyOf(typeParameterRequirements), returnType, ImmutableList.copyOf(argumentTypes), variableArity);
     }
 
     @Override
@@ -96,7 +96,7 @@ public SimpleSqlScalarFunction(
                     signature.getArgumentTypes().stream()
                             .map(TypeSignature::toString)
                             .collect(ImmutableCollectors.toImmutableList()));
-            checkArgument(signature.getTypeParameters().isEmpty(), "%s is parametric", signature);
+            checkArgument(signature.getTypeParameterRequirements().isEmpty(), "%s is parametric", signature);
             this.description = description;
             this.hidden = hidden;
             this.methodHandle = requireNonNull(methodHandle, "methodHandle is null");