chore: Hardware failure.

Author: masmangan

assis-core/src/main/java/io/github/masmangan/assis/internal/CollectDependenciesVisitor.java

@@ -132,12 +132,18 @@ public void visit(ClassExpr n, DependencyContext ctx) {
 	// no samples!
 	@Override
 	public void visit(MethodCallExpr n, DependencyContext ctx) {
-		n.getScope().ifPresent(scope -> {
-			if (scope instanceof NameExpr ne) {
-				recordScope(ne.getNameAsString(), n, ctx);
-			}
-		});
-		super.visit(n, ctx);
+	    n.getScope().ifPresent(scope -> {
+	        if (scope instanceof NameExpr ne) {
+	            recordScope(ne, n, ctx);        // pass the node
+	        }
+	    });
+	    super.visit(n, ctx);
+	}
+
+	private void recordScope(NameExpr scopeExpr, Node site, DependencyContext ctx) {
+	    if (ownerStack.isEmpty()) return;
+	    ctx.resolveScope(scopeExpr, site)
+	       .ifPresent(target -> collect(owner(), target, ctx));
 	}
 
 	private void enter(TypeDeclaration<?> td) {

assis-core/src/main/java/io/github/masmangan/assis/internal/DeclaredIndex.java

@@ -29,6 +29,7 @@
 import com.github.javaparser.ast.body.EnumDeclaration;
 import com.github.javaparser.ast.body.Parameter;
 import com.github.javaparser.ast.body.TypeDeclaration;
+import com.github.javaparser.ast.expr.NameExpr;
 import com.github.javaparser.ast.nodeTypes.NodeWithAnnotations;
 import com.github.javaparser.ast.nodeTypes.modifiers.NodeWithAccessModifiers;
 import com.github.javaparser.ast.type.ArrayType;
@@ -660,4 +661,64 @@ public Optional<TypeRef> resolveScopeName(String simpleName, Node usageSite) {
 		return Optional.of(new UnresolvedTypeRef(simpleName));
 	}
 
+	public Optional<TypeRef> resolveScope(NameExpr scopeExpr, Node usageSite) {
+	    try {
+	        var valueDecl = scopeExpr.resolve();          // ResolvedValueDeclaration
+	        var valueType = valueDecl.getType();          // ResolvedType
+	        return resolveResolvedTypeToTypeRef(valueType, usageSite);
+	    } catch (Exception e) {
+	        // fallback(s) below
+	    }
+
+	    // Fallback 1: sometimes NameExpr is actually a type name used as qualifier (static call)
+	    String name = scopeExpr.getNameAsString();
+	    TypeDeclaration<?> indexed = getByFqn(name);
+	    if (indexed != null) return Optional.of(new DeclaredTypeRef(indexed));
+
+	    // Fallback 2: return unresolved *type* ref? I'd avoid emitting a dependency to a bare variable name:
+	    return Optional.empty(); // <- prevents "A ..> b"
+	}
+	
+	private Optional<TypeRef> resolveResolvedTypeToTypeRef(
+	        ResolvedType rt,
+	        Node usageSite
+	) {
+	    // 1) Primitives → no dependency
+	    if (rt.isPrimitive()) {
+	        return Optional.empty();
+	    }
+
+	    // 2) Void → no dependency
+	    if (rt.isVoid()) {
+	        return Optional.empty();
+	    }
+
+	    // 3) Reference types (classes, interfaces, enums)
+	    if (rt.isReferenceType()) {
+	        var rrt = rt.asReferenceType();
+	        var qname = rrt.getQualifiedName(); // dot-qualified, not JVM $
+
+	        // a) Declared in our parsed sources
+	        TypeDeclaration<?> td = getByFqn(qname);
+	        if (td != null) {
+	            return Optional.of(new DeclaredTypeRef(td));
+	        }
+
+	        // b) Known but external (JDK, libs)
+	        return Optional.of(new ExternalTypeRef(qname));
+	    }
+
+	    // 4) Arrays → dependency on component type
+	    if (rt.isArray()) {
+	        return resolveResolvedTypeToTypeRef(
+	                rt.asArrayType().getComponentType(),
+	                usageSite
+	        );
+	    }
+
+	    // 5) Type variables, wildcards, etc.
+	    // Usually not diagram-worthy on their own
+	    return Optional.empty();
+	}
+
 }

assis-core/src/main/java/io/github/masmangan/assis/internal/DependencyContext.java

@@ -9,6 +9,8 @@
 
 import com.github.javaparser.ast.Node;
 import com.github.javaparser.ast.body.TypeDeclaration;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.NameExpr;
 import com.github.javaparser.ast.type.Type;
 
 import io.github.masmangan.assis.io.PlantUMLWriter;
@@ -106,4 +108,12 @@ public void addCherryPick(TypeDeclaration<?> from, TypeRef to) {
 		er.registerDependency(fromFqn, toFqn);
 	}
 
+	public Optional<TypeRef> resolveScope(NameExpr scopeExpr, Node usageSite) {
+	    return idx.resolveScope(scopeExpr, usageSite);
+	}
+	
 }
+		
+		
+		
+