Validated right hand expression type is the expected type at variable declaration, and underlined the mismatched type's token if not.

Author: bigguy345

src/main/java/noppes/npcs/client/gui/util/GuiScriptTextArea.java

@@ -839,6 +839,7 @@ public void drawTextBox(int xMouse, int yMouse) {
 
                // data.drawString(x + LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0);
                 scriptLine.drawString(x+LINE_NUMBER_GUTTER_WIDTH + 1, yPos, 0xFFe0e0e0);
+               // scriptLine.drawStringHex(x+LINE_NUMBER_GUTTER_WIDTH + 1, yPos, ScriptLine.createDefaultHexRenderer());
 
                 // Draw cursor: pause blinking while user is active recently
                 boolean recentInput = selection.hadRecentInput();

src/main/java/noppes/npcs/client/gui/util/script/interpreter/FieldAccessInfo.java

@@ -0,0 +1,172 @@
+package noppes.npcs.client.gui.util.script.interpreter;
+
+/**
+ * Metadata for field access validation.
+ * Parallel to MethodCallInfo but for field accesses like `obj.field` or `Class.staticField`.
+ */
+public class FieldAccessInfo {
+
+    /**
+     * Validation error type for field accesses.
+     */
+    public enum ErrorType {
+        NONE,
+        TYPE_MISMATCH,        // Field type doesn't match expected type (e.g., assignment LHS)
+        UNRESOLVED_FIELD,     // Field doesn't exist on the receiver type
+        STATIC_ACCESS_ERROR   // Trying to access instance field statically or vice versa
+    }
+
+    private final String fieldName;
+    private final int fieldNameStart;
+    private final int fieldNameEnd;
+    private final TypeInfo receiverType;    // The type on which this field is accessed
+    private final FieldInfo resolvedField;  // The resolved field (null if unresolved)
+    private final boolean isStaticAccess;   // True if this is Class.field style access
+    private TypeInfo expectedType;          // Expected field type (from assignment LHS, etc.)
+
+    private ErrorType errorType = ErrorType.NONE;
+    private String errorMessage;
+
+    public FieldAccessInfo(String fieldName, int fieldNameStart, int fieldNameEnd,
+                           TypeInfo receiverType, FieldInfo resolvedField, boolean isStaticAccess) {
+        this.fieldName = fieldName;
+        this.fieldNameStart = fieldNameStart;
+        this.fieldNameEnd = fieldNameEnd;
+        this.receiverType = receiverType;
+        this.resolvedField = resolvedField;
+        this.isStaticAccess = isStaticAccess;
+    }
+
+    // Getters
+    public String getFieldName() {
+        return fieldName;
+    }
+
+    public int getFieldNameStart() {
+        return fieldNameStart;
+    }
+
+    public int getFieldNameEnd() {
+        return fieldNameEnd;
+    }
+
+    public TypeInfo getReceiverType() {
+        return receiverType;
+    }
+
+    public FieldInfo getResolvedField() {
+        return resolvedField;
+    }
+
+    public boolean isStaticAccess() {
+        return isStaticAccess;
+    }
+
+    public TypeInfo getExpectedType() {
+        return expectedType;
+    }
+
+    public void setExpectedType(TypeInfo expectedType) {
+        this.expectedType = expectedType;
+    }
+
+    public ErrorType getErrorType() {
+        return errorType;
+    }
+
+    public String getErrorMessage() {
+        return errorMessage;
+    }
+
+    /**
+     * Validate this field access.
+     * Checks type compatibility with expected type.
+     */
+    public void validate() {
+        // Check if field was resolved
+        if (resolvedField == null) {
+            setError(ErrorType.UNRESOLVED_FIELD, "Cannot resolve field '" + fieldName + "'");
+            return;
+        }
+
+        // Check return type compatibility with expected type (e.g., assignment LHS)
+        if (expectedType != null && resolvedField != null) {
+            TypeInfo fieldType = resolvedField.getDeclaredType();
+            if (fieldType != null && !isTypeCompatible(fieldType, expectedType)) {
+                setError(ErrorType.TYPE_MISMATCH,
+                        "Required type: " + expectedType.getSimpleName() + ", Provided: " + fieldType.getSimpleName());
+            }
+        }
+    }
+
+    /**
+     * Check if sourceType can be assigned to targetType.
+     */
+    private boolean isTypeCompatible(TypeInfo sourceType, TypeInfo targetType) {
+        if (sourceType == null || targetType == null) {
+            return true; // Can't validate, assume compatible
+        }
+
+        // Same type
+        if (sourceType.getFullName().equals(targetType.getFullName())) {
+            return true;
+        }
+
+        // Check if sourceType is a subtype of targetType
+        if (sourceType.isResolved() && targetType.isResolved()) {
+            Class<?> sourceClass = sourceType.getJavaClass();
+            Class<?> targetClass = targetType.getJavaClass();
+
+            if (sourceClass != null && targetClass != null) {
+                return targetClass.isAssignableFrom(sourceClass);
+            }
+        }
+
+        // Primitive widening/boxing conversions would go here
+        // For now, just check direct equality
+        return false;
+    }
+
+    private void setError(ErrorType type, String message) {
+        this.errorType = type;
+        this.errorMessage = message;
+    }
+
+    /**
+     * Check if this field access has any validation error.
+     */
+    public boolean hasError() {
+        return errorType != ErrorType.NONE;
+    }
+
+    /**
+     * Check if this is a type mismatch error.
+     */
+    public boolean hasTypeMismatch() {
+        return errorType == ErrorType.TYPE_MISMATCH;
+    }
+
+    /**
+     * Check if this is an unresolved field error.
+     */
+    public boolean hasUnresolvedField() {
+        return errorType == ErrorType.UNRESOLVED_FIELD;
+    }
+
+    /**
+     * Check if this is a static access error.
+     */
+    public boolean hasStaticAccessError() {
+        return errorType == ErrorType.STATIC_ACCESS_ERROR;
+    }
+
+    @Override
+    public String toString() {
+        return "FieldAccessInfo{" +
+                "fieldName='" + fieldName + "', " +
+                "receiverType=" + receiverType + ", " +
+                "resolvedField=" + resolvedField + ", " +
+                "errorType=" + errorType +
+                '}';
+    }
+}

src/main/java/noppes/npcs/client/gui/util/script/interpreter/MethodCallInfo.java

@@ -79,6 +79,7 @@ public enum ErrorType {
         WRONG_ARG_COUNT,       // Number of args doesn't match any overload
         WRONG_ARG_TYPE,        // Specific argument has wrong type
         STATIC_ACCESS_ERROR,   // Trying to call instance method statically or vice versa
+        RETURN_TYPE_MISMATCH,  // Return type doesn't match expected type (e.g., assignment LHS)
         UNRESOLVED_METHOD,     // Method doesn't exist
         UNRESOLVED_RECEIVER    // Can't resolve the receiver type
     }
@@ -92,6 +93,7 @@ public enum ErrorType {
     private final TypeInfo receiverType;     // The type on which this method is called (null for standalone)
     private final MethodInfo resolvedMethod; // The resolved method (null if unresolved)
     private final boolean isStaticAccess;    // True if this is Class.method() style access
+    private TypeInfo expectedType;           // Expected return type (from assignment LHS, etc.)
 
     private ErrorType errorType = ErrorType.NONE;
     private String errorMessage;
@@ -162,6 +164,14 @@ public boolean isStaticAccess() {
         return isStaticAccess;
     }
 
+    public TypeInfo getExpectedType() {
+        return expectedType;
+    }
+
+    public void setExpectedType(TypeInfo expectedType) {
+        this.expectedType = expectedType;
+    }
+
     public ErrorType getErrorType() {
         return errorType;
     }
@@ -211,6 +221,13 @@ public boolean hasStaticAccessError() {
         return errorType == ErrorType.STATIC_ACCESS_ERROR;
     }
 
+    /**
+     * Check if this is a return type mismatch error.
+     */
+    public boolean hasReturnTypeMismatch() {
+        return errorType == ErrorType.RETURN_TYPE_MISMATCH;
+    }
+
     // Setters for validation results
     public void setError(ErrorType type, String message) {
         this.errorType = type;
@@ -296,6 +313,15 @@ public void validate() {
                 setArgTypeError(i, "Cannot resolve type of argument '" + arg.getText() + "'");
             }
         }
+
+        // Check return type compatibility with expected type (e.g., assignment LHS)
+        if (expectedType != null && resolvedMethod != null) {
+            TypeInfo returnType = resolvedMethod.getReturnType();
+            if (returnType != null && !isTypeCompatible(returnType, expectedType)) {
+                setError(ErrorType.RETURN_TYPE_MISMATCH,
+                        "Required type: " + expectedType.getSimpleName() + ", Provided: " + returnType.getSimpleName());
+            }
+        }
     }
 
     /**