fix: DROP ENUMERATION errors on ambiguous unqualified name (#391)

The loop previously dropped the first enumeration found with a matching
name when no module was specified, silently ignoring other modules that
had an enumeration with the same name.

Rewritten to collect all matches first:
- 0 matches → not found
- 1 match   → delete (qualified or unambiguous unqualified)
- 2+ matches → validation error listing all matching qualified names,
               asking the user to qualify the name

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: ako

mdl/executor/cmd_enumerations.go

@@ -127,21 +127,42 @@ func execDropEnumeration(ctx *ExecContext, s *ast.DropEnumerationStmt) error {
 		return mdlerrors.NewBackend("list enumerations", err)
 	}
 
+	// Collect all enumerations matching the name (and optional module).
+	type match struct {
+		enum   *model.Enumeration
+		module *model.Module
+	}
+	var matches []match
 	for _, enum := range enums {
-		if enum.Name == s.Name.Name {
-			// Check module matches
-			module, err := findModuleByID(ctx, enum.ContainerID)
-			if err == nil && (s.Name.Module == "" || module.Name == s.Name.Module) {
-				if err := ctx.Backend.DeleteEnumeration(enum.ID); err != nil {
-					return mdlerrors.NewBackend("delete enumeration", err)
-				}
-				fmt.Fprintf(ctx.Output, "Dropped enumeration: %s\n", s.Name)
-				return nil
-			}
+		if enum.Name != s.Name.Name {
+			continue
+		}
+		module, err := findModuleByID(ctx, enum.ContainerID)
+		if err != nil {
+			continue
+		}
+		if s.Name.Module == "" || module.Name == s.Name.Module {
+			matches = append(matches, match{enum, module})
 		}
 	}
 
-	return mdlerrors.NewNotFound("enumeration", s.Name.String())
+	switch len(matches) {
+	case 0:
+		return mdlerrors.NewNotFound("enumeration", s.Name.String())
+	case 1:
+		if err := ctx.Backend.DeleteEnumeration(matches[0].enum.ID); err != nil {
+			return mdlerrors.NewBackend("delete enumeration", err)
+		}
+		fmt.Fprintf(ctx.Output, "Dropped enumeration: %s.%s\n", matches[0].module.Name, s.Name.Name)
+		return nil
+	default:
+		var names []string
+		for _, m := range matches {
+			names = append(names, m.module.Name+"."+s.Name.Name)
+		}
+		return mdlerrors.NewValidationf("ambiguous enumeration name %q — found in: %s; use a fully-qualified name",
+			s.Name.Name, strings.Join(names, ", "))
+	}
 }
 
 // listEnumerations handles SHOW ENUMERATIONS command.

mdl/executor/cmd_enumerations_mock_test.go

@@ -98,5 +98,62 @@ func TestDescribeEnumeration_Mock_NotFound(t *testing.T) {
 	assertError(t, err)
 }
 
+// Issue #391 — DROP ENUMERATION with an unqualified name must error when
+// the name matches enumerations in multiple modules, not silently drop one.
+func TestDropEnumeration_AmbiguousUnqualified_Issue391(t *testing.T) {
+	mod1 := mkModule("Mod1")
+	mod2 := mkModule("Mod2")
+	e1 := mkEnumeration(mod1.ID, "Status", "Active", "Inactive")
+	e2 := mkEnumeration(mod2.ID, "Status", "Open", "Closed")
+
+	h := mkHierarchy(mod1, mod2)
+	withContainer(h, e1.ContainerID, mod1.ID)
+	withContainer(h, e2.ContainerID, mod2.ID)
+
+	mb := &mock.MockBackend{
+		IsConnectedFunc:      func() bool { return true },
+		ListModulesFunc:      func() ([]*model.Module, error) { return []*model.Module{mod1, mod2}, nil },
+		ListEnumerationsFunc: func() ([]*model.Enumeration, error) { return []*model.Enumeration{e1, e2}, nil },
+	}
+
+	ctx, _ := newMockCtx(t, withBackend(mb), withHierarchy(h))
+	err := execDropEnumeration(ctx, &ast.DropEnumerationStmt{
+		Name: ast.QualifiedName{Name: "Status"}, // unqualified
+	})
+	assertError(t, err)
+	assertContainsStr(t, err.Error(), "ambiguous")
+}
+
+func TestDropEnumeration_Qualified_Success(t *testing.T) {
+	mod1 := mkModule("Mod1")
+	mod2 := mkModule("Mod2")
+	e1 := mkEnumeration(mod1.ID, "Status", "Active")
+	e2 := mkEnumeration(mod2.ID, "Status", "Open")
+	deleted := ""
+
+	h := mkHierarchy(mod1, mod2)
+	withContainer(h, e1.ContainerID, mod1.ID)
+	withContainer(h, e2.ContainerID, mod2.ID)
+
+	mb := &mock.MockBackend{
+		IsConnectedFunc:      func() bool { return true },
+		ListModulesFunc:      func() ([]*model.Module, error) { return []*model.Module{mod1, mod2}, nil },
+		ListEnumerationsFunc: func() ([]*model.Enumeration, error) { return []*model.Enumeration{e1, e2}, nil },
+		DeleteEnumerationFunc: func(id model.ID) error {
+			deleted = string(id)
+			return nil
+		},
+	}
+
+	ctx, _ := newMockCtx(t, withBackend(mb), withHierarchy(h))
+	err := execDropEnumeration(ctx, &ast.DropEnumerationStmt{
+		Name: ast.QualifiedName{Module: "Mod1", Name: "Status"},
+	})
+	assertNoError(t, err)
+	if deleted != string(e1.ID) {
+		t.Errorf("expected Mod1.Status (id=%s) to be deleted, got %s", e1.ID, deleted)
+	}
+}
+
 // Backend error: cmd_error_mock_test.go (TestShowEnumerations_Mock_BackendError)
 // JSON: cmd_json_mock_test.go (TestShowEnumerations_Mock_JSON)