All varargs i.e 'String...' handling is now completely functional

This commit is contained in:
bigguy345 committed 2026-03-06 05:09:36 +02:00
1 parent 8ccdabef47
commit ff81281337
12 files changed
+110 -33

No files matched your search

@@ -121,6 +121,7 @@ public class AutocompleteItem implements Comparable<AutocompleteItem> {
String paramType = param.getTypeInfo() != null ?
getName(param.getTypeInfo()) : "?";
displayName.append(paramType);
if (param.isVarArg()) displayName.append("...");
if (param.getName() != null && !param.getName().isEmpty()) {
displayName.append(" ").append(param.getName());
}
@@ -269,6 +270,7 @@ public class AutocompleteItem implements Comparable<AutocompleteItem> {
// Use resolved type with full generic display
TypeInfo paramType = param.getResolvedType(contextType);
String paramTypeName = paramType.isResolved() ? paramType.getDisplayName() : param.getType();
if (param.isVarArg()) paramTypeName = paramTypeName + "...";
displayName.append(paramTypeName).append(" ").append(param.getName());
}
displayName.append(")");
@@ -464,7 +466,9 @@ public class AutocompleteItem implements Comparable<AutocompleteItem> {
FieldInfo param = method.getParameters().get(i);
String paramType = param.getTypeInfo() != null ?
getName(param.getTypeInfo()) : "?";
sb.append(paramType).append(" ").append(param.getName());
sb.append(paramType);
if (param.isVarArg()) sb.append("...");
sb.append(" ").append(param.getName());
}
sb.append(")");
@@ -1229,10 +1229,14 @@ public class ScriptDocument {
while (m.find()) {
String typeName = m.group(1);
String paramName = m.group(2);
boolean isVarArg = typeName.endsWith("...");
if (isVarArg) typeName = typeName.substring(0, typeName.length() - 3);
TypeInfo typeInfo = resolveType(typeName);
// Store the absolute position of the parameter name
int paramNameStart = paramListStart + m.start(2);
params.add(FieldInfo.parameter(paramName, typeInfo, paramNameStart, null));
FieldInfo fieldInfo = FieldInfo.parameter(paramName, typeInfo, paramNameStart, null);
fieldInfo.setVarArg(isVarArg);
params.add(fieldInfo);
}
return params;
}
@@ -2295,18 +2299,23 @@ public class ScriptDocument {
// Typed: Type name
paramName = parts[parts.length - 1];
String typeName = parts[parts.length - 2];
boolean isVarArg = typeName.endsWith("...");
if (isVarArg) typeName = typeName.substring(0, typeName.length() - 3);
paramType = resolveType(typeName);
int nameOffset = text.indexOf(paramName, paramOffset);
if (nameOffset < 0) nameOffset = paramOffset;
FieldInfo paramInfo = FieldInfo.parameter(paramName, paramType, nameOffset, null);
paramInfo.setVarArg(isVarArg);
scope.addParameter(paramInfo);
} else {
// Untyped: just name (type will be inferred from expected FI)
paramName = parts[0];
int nameOffset = text.indexOf(paramName, paramOffset);
if (nameOffset < 0) nameOffset = paramOffset;
FieldInfo paramInfo = FieldInfo.parameter(paramName, paramType, nameOffset, null);
scope.addParameter(paramInfo);
}
int nameOffset = text.indexOf(paramName, paramOffset);
if (nameOffset < 0) nameOffset = paramOffset;
FieldInfo paramInfo = FieldInfo.parameter(paramName, paramType, nameOffset, null);
scope.addParameter(paramInfo);
offset = paramOffset + param.length();
}
}
@@ -66,6 +66,8 @@ public final class FieldInfo {
// Enum constant specific info
private EnumConstantInfo enumConstantInfo;
private boolean isVarArg = false;
// Type inference support (for JavaScript "any" typed variables)
// When a variable is declared without type (var x;), it starts as "any" but can be
// refined through assignments or JSDoc comments
@@ -485,6 +487,9 @@ public final class FieldInfo {
* Used when type inference determines a more specific type than the declared type.
* @param inferredType The refined type based on assignments or JSDoc
*/
public void setVarArg(boolean isVarArg) { this.isVarArg = isVarArg; }
public boolean isVarArg() { return isVarArg; }
public void setInferredType(TypeInfo inferredType) {
this.inferredType = inferredType;
}
@@ -1083,6 +1083,9 @@ public class TokenHoverInfo {
TypeInfo paramType = param.getTypeInfo();
if (paramType != null) {
addTypeSegments(paramType);
if (param.isVarArg()) {
addSegment("...", TokenType.DEFAULT.getHexColor());
}
addSegment(" ", TokenType.DEFAULT.getHexColor());
}
addSegment(param.getName(), TokenType.PARAMETER.getHexColor());
@@ -1136,6 +1139,9 @@ public class TokenHoverInfo {
int paramTypeColor = getColorForClass(paramTypes[i]);
String paramTypeName = paramTypes[i].getSimpleName();
splitAndAddTypeName(paramTypeName, paramTypeColor);
if (method.isVarArgs() && i == paramTypes.length - 1) {
addSegment("...", TokenType.DEFAULT.getHexColor());
}
addSegment(" ", TokenType.DEFAULT.getHexColor());
// Try to get parameter name if available
String paramName = params.length > i ? params[i].getName() : "arg" + i;
@@ -1181,6 +1187,9 @@ public class TokenHoverInfo {
TypeInfo paramType = param.getTypeInfo();
if (paramType != null) {
addTypeSegments(paramType);
if (param.isVarArg()) {
addSegment("...", TokenType.DEFAULT.getHexColor());
}
addSegment(" ", TokenType.DEFAULT.getHexColor());
}
addSegment(param.getName(), TokenType.PARAMETER.getHexColor());
@@ -142,12 +142,16 @@ public class JSMethodInfo {
private final String type;
private TypeInfo typeInfo; // Resolved TypeInfo (set during Phase 2)
private JSMethodInfo containingMethod; // The type that contains the method with this parameter
private boolean isVarArg = false;
public JSParameterInfo(String name, String type) {
this.name = name;
this.type = type;
}
public void setVarArg(boolean isVarArg) { this.isVarArg = isVarArg; }
public boolean isVarArg() { return isVarArg; }
public void setContainingMethod(JSMethodInfo containingMethod) {
this.containingMethod = containingMethod;
}
@@ -630,12 +630,16 @@ public class TypeScriptDefinitionParser {
part = part.trim();
if (part.isEmpty()) continue;
// Format: name: type or name?: type
// Format: name: type or name?: type or ...name: type
int colonIndex = part.indexOf(':');
if (colonIndex > 0) {
String name = part.substring(0, colonIndex).trim().replace("?", "");
String type = cleanType(part.substring(colonIndex + 1).trim());
result.add(new JSMethodInfo.JSParameterInfo(name, type));
boolean isVarArg = name.startsWith("...");
if (isVarArg) name = name.substring(3).trim();
JSMethodInfo.JSParameterInfo param = new JSMethodInfo.JSParameterInfo(name, type);
param.setVarArg(isVarArg);
result.add(param);
}
}
@@ -339,8 +339,13 @@ public class MethodCallInfo {
setError(ErrorType.UNRESOLVED_METHOD,
"Cannot resolve constructor for '" + methodName + "'");
}
} else if (receiverType != null && arguments.size() == resolvedMethod.getParameterCount()) {
validateArgTypeError();
} else if (receiverType != null) {
List<FieldInfo> cParams = resolvedMethod.getParameters();
boolean ctorVarArg = !cParams.isEmpty() && cParams.get(cParams.size() - 1).isVarArg();
boolean ctorCountOk = ctorVarArg
? arguments.size() >= cParams.size() - 1
: arguments.size() == resolvedMethod.getParameterCount();
if (ctorCountOk) validateArgTypeError();
}
return;
}
@@ -356,12 +361,21 @@ public class MethodCallInfo {
List<FieldInfo> params = resolvedMethod.getParameters();
int expectedCount = params.size();
int actualCount = arguments.size();
boolean isVarArgMethod = expectedCount > 0 && params.get(expectedCount - 1).isVarArg();
// Check arg count
if (actualCount != expectedCount) {
setError(ErrorType.WRONG_ARG_COUNT,
"Expected " + expectedCount + " argument(s) but got " + actualCount);
return;
if (isVarArgMethod) {
if (actualCount < expectedCount - 1) {
setError(ErrorType.WRONG_ARG_COUNT,
"Expected at least " + (expectedCount - 1) + " argument(s) but got " + actualCount);
return;
}
} else {
if (actualCount != expectedCount) {
setError(ErrorType.WRONG_ARG_COUNT,
"Expected " + expectedCount + " argument(s) but got " + actualCount);
return;
}
}
// Check each argument type
@@ -379,7 +393,10 @@ public class MethodCallInfo {
}
public void validateArgTypeError() {
// Check each argument type
List<FieldInfo> params = resolvedMethod.getParameters();
int paramCount = params.size();
boolean isVarArgMethod = paramCount > 0 && params.get(paramCount - 1).isVarArg();
for (int i = 0; i < arguments.size(); i++) {
Argument arg = arguments.get(i);
@@ -389,10 +406,19 @@ public class MethodCallInfo {
continue; // Skip remaining checks for this argument
}
FieldInfo para = resolvedMethod.getParameters().get(i);
// Varargs: all args at index >= (paramCount-1) map to the element type of the last param
FieldInfo para;
TypeInfo paramType;
if (isVarArgMethod && i >= paramCount - 1) {
para = params.get(paramCount - 1);
TypeInfo arrType = para.getTypeInfo();
paramType = (arrType != null && arrType.isArray()) ? arrType.getElementType() : arrType;
} else {
para = params.get(i);
paramType = para.getTypeInfo();
}
TypeInfo argType = arg.getResolvedType();
TypeInfo paramType = para.getTypeInfo();
if (argType != null && paramType != null) {
if (!TypeChecker.isTypeCompatible(paramType, argType)) {
setArgTypeError(i, "Expected " + paramType.getDisplayName() +
@@ -206,7 +206,14 @@ public final class MethodInfo {
paramName = jsName;
}
}
params.add(FieldInfo.reflectionParam(paramName, paramType));
FieldInfo fieldInfo = FieldInfo.reflectionParam(paramName, paramType);
boolean isVarArg = method.isVarArgs() && i == genericParamTypes.length - 1;
if (jsParams != null && i < jsParams.size()) {
isVarArg = isVarArg || jsParams.get(i).isVarArg();
}
fieldInfo.setVarArg(isVarArg);
params.add(fieldInfo);
}
String documentation = null;
@@ -242,7 +249,9 @@ public final class MethodInfo {
if (paramType == null) {
paramType = TypeInfo.fromClass(constructor.getParameterTypes()[i]);
}
params.add(FieldInfo.reflectionParam("arg" + i, paramType));
FieldInfo fieldInfo = FieldInfo.reflectionParam("arg" + i, paramType);
fieldInfo.setVarArg(constructor.isVarArgs() && i == genericParamTypes.length - 1);
params.add(fieldInfo);
}
return new MethodInfo(name, returnType, containingType, params, -1, -1, -1, -1, -1, true, true, modifiers, null, null);
@@ -272,7 +281,9 @@ public final class MethodInfo {
// Use the new getResolvedType method
TypeInfo paramType = param.getResolvedType(containingType);
params.add(FieldInfo.reflectionParam(paramName, paramType));
FieldInfo fieldInfo = FieldInfo.reflectionParam(paramName, paramType);
fieldInfo.setVarArg(param.isVarArg());
params.add(fieldInfo);
}
// JS methods are always public (no access modifiers in .d.ts)
@@ -62,11 +62,16 @@ public class SyntheticMethod {
public MethodInfo toMethodInfo(TypeInfo containingType) {
List<FieldInfo> paramInfos = new ArrayList<>();
for (SyntheticParameter param : parameters) {
TypeInfo paramType = TypeResolver.getInstance().resolve(param.typeName);
String typeName = param.typeName;
boolean isVarArg = typeName != null && typeName.endsWith("...");
if (isVarArg) typeName = typeName.substring(0, typeName.length() - 3);
TypeInfo paramType = TypeResolver.getInstance().resolve(typeName);
if (paramType == null) {
paramType = TypeInfo.unresolved(param.typeName, param.typeName);
paramType = TypeInfo.unresolved(typeName, typeName);
}
paramInfos.add(FieldInfo.parameter(param.name, paramType, -1, null));
FieldInfo fieldInfo = FieldInfo.parameter(param.name, paramType, -1, null);
fieldInfo.setVarArg(isVarArg);
paramInfos.add(fieldInfo);
}
TypeInfo returnTypeInfo = TypeResolver.getInstance().resolve(returnType);