chore: hang filename off of ast nodes and refactor accordingly

internal/services/shared/errors_test.go

@@ -196,6 +196,7 @@ func TestRewriteError(t *testing.T) {
 			inputError: spiceerrors.NewWithSourceError(
 				fmt.Errorf("invalid schema definition"),
 				"definition document {\n  relation viewer: user\n}",
+				"source",
 				1,
 				1,
 			),

pkg/development/devcontext.go

@@ -334,7 +334,6 @@ func getDevError(cverr error, compiled *compiler.CompiledSchema, definitionOrCav
 	if cverr == nil || compiled == nil || definitionOrCaveat == nil {
 		return nil
 	}
-	path := compiled.GetPathToDefinitionOrPartialOrCaveat(definitionOrCaveat.GetName())
 	errWithSource, ok := spiceerrors.AsWithSourceError(cverr)
 	if ok {
 		// NOTE: zeroes are fine here to mean "unknown"
@@ -354,15 +353,16 @@ func getDevError(cverr error, compiled *compiler.CompiledSchema, definitionOrCav
 			Context: errWithSource.SourceCodeString,
 			Line:    lineNumber,
 			Column:  columnPosition,
-			Path:    []string{path},
+			Path:    []string{errWithSource.FileName},
 		}
 	}
 	return &devinterface.DeveloperError{
 		Message: cverr.Error(),
 		Kind:    devinterface.DeveloperError_SCHEMA_ISSUE,
 		Source:  devinterface.DeveloperError_SCHEMA,
 		Context: definitionOrCaveat.GetName(),
-		Path:    []string{path},
+		// TODO: do we have any additional context here?
+		Path: []string{""},
 	}
 }
 

pkg/development/schema_position_mapper.go

@@ -92,9 +92,10 @@
 	if importPath, ok := r.importReferenceChain(nodeChain); ok {
 		importSource := input.Source(importPath)
 		return &SchemaReference{
-			ReferenceType:  ReferenceTypeImport,
-			Source:         source,
-			Position:       position,
+			ReferenceType: ReferenceTypeImport,
+			Source:        source,
+			Position:      position,
+			// TODO: is this the path pointed at by the import, or is it the position of the import reference itself?
 			TargetSource:   &importSource,
 			TargetPosition: &input.Position{LineNumber: 0, ColumnPosition: 0},
 			Text:           importPath,
@@ -109,7 +110,7 @@
 			targetPosition = &input.Position{LineNumber: line, ColumnPosition: col}
 		}
 
 		targetSource := r.resolveTargetSource(partialName, source)
 		return &SchemaReference{
 			Source:                   source,
 			Position:                 position,
@@ -142,7 +143,7 @@
 			return nil, err
 		}
 
 		targetSource := r.resolveTargetSource(relation.Name, source)
 
 		if def.IsPermission(relation.Name) {
 			return &SchemaReference{
@@ -209,7 +210,7 @@
 			targetSourceCode = fmt.Sprintf("%sdefinition %s {}", docComment, def.Name)
 		}
 
 		targetSource := r.resolveTargetSource(def.Name, source)
 		return &SchemaReference{
 			Source:   source,
 			Position: position,
@@ -255,7 +256,7 @@
 		}
 		caveatSourceCode.WriteString(") {\n\t// ...\n}")
 
 		targetSource := r.resolveTargetSource(caveatDef.Name, source)
 		return &SchemaReference{
 			Source:   source,
 			Position: position,
@@ -279,7 +280,7 @@
 	// Caveat parameter used in expression.
 	if caveatParamName, paramTypeString, caveatDef, ok := r.caveatParamChain(nodeChain, source, position); ok {
 		targetSourceCode := fmt.Sprintf("%s %s", caveatParamName, paramTypeString)
 		targetSource := r.resolveTargetSource(caveatDef.Name, source)
 		return &SchemaReference{
 			Source:   source,
 			Position: position,
@@ -296,16 +297,6 @@
 	return nil, nil
 }
 
-// resolveTargetSource returns the input.Source for the file where a definition or caveat
-// is defined. For imported definitions, this will be the imported file path. For definitions
-// in the root schema, this returns the fallback source.
-func (r *SchemaPositionMapper) resolveTargetSource(name string, fallback input.Source) input.Source {
-	if defSource := r.schema.GetPathToDefinitionOrPartialOrCaveat(name); defSource != "" {
-		return input.Source(defSource)
-	}
-	return fallback
-}
-
 func (r *SchemaPositionMapper) lookupCaveat(caveatName string) (*core.CaveatDefinition, bool) {
 	c, err := r.typeSystem.GetCaveat(context.Background(), caveatName)
 	if err != nil {

pkg/schema/errors.go

@@ -423,14 +423,16 @@
 		return asTypeError(spiceerrors.NewWithSourceError(
 			wrapped,
 			sourceCodeString,
-			sourcePosition.ZeroIndexedLineNumber+1, // +1 to make 1-indexed
+			sourcePosition.FileName,
+			sourcePosition.ZeroIndexedLineNumber+1,     // +1 to make 1-indexed
 			sourcePosition.ZeroIndexedColumnPosition+1, // +1 to make 1-indexed
 		))
 	}
 
 	return asTypeError(spiceerrors.NewWithSourceError(
 		wrapped,
 		sourceCodeString,
+		"",
 		0,
 		0,
 	))

pkg/schemadsl/compiler/development.go

@@ -55,41 +55,6 @@ func (nc *NodeChain) String() string {
 	return out.String()
 }
 
-// GetPathToDefinitionOrPartialOrCaveat returns the input source for the AST node defining the given name.
-// For definitions compiled from imports, this will be the imported file path (e.g. "users.zed").
-// For definitions in the root schema, this will be the root source (e.g. "schema").
-// Returns empty string if not found.
-func (cs *CompiledSchema) GetPathToDefinitionOrPartialOrCaveat(name string) string {
-	for _, child := range cs.rootNode.GetChildren() {
-		nodeType := child.GetType()
-		var predicateName string
-		switch nodeType {
-		case dslshape.NodeTypeDefinition:
-			predicateName = dslshape.NodeDefinitionPredicateName
-		case dslshape.NodeTypeCaveatDefinition:
-			predicateName = dslshape.NodeCaveatDefinitionPredicateName
-		case dslshape.NodeTypePartial:
-			predicateName = dslshape.NodePartialPredicateName
-		default:
-			continue
-		}
-
-		defName, err := child.GetString(predicateName)
-		if err != nil {
-			continue
-		}
-
-		if defName == name {
-			source, err := child.GetString(dslshape.NodePredicateSource)
-			if err != nil {
-				return ""
-			}
-			return source
-		}
-	}
-	return ""
-}
-
 // PartialNodePosition returns the start rune position and source of the partial
 // definition with the given name. Returns (-1, -1, "") if not found.
 func (cs *CompiledSchema) PartialNodePosition(name string) (int, int) {

pkg/schemadsl/compiler/translator.go

@@ -336,6 +336,10 @@
 		return nil
 	}
 
+	if !dslNode.Has(dslshape.NodePredicateSource) {
+		return nil
+	}
+
 	sourceRange, err := dslNode.Range(mapper)
 	if err != nil {
 		return nil
@@ -355,9 +359,15 @@
 		uintCol = 0
 	}
 
+	filename, err := dslNode.GetString(dslshape.NodePredicateSource)
+	if err != nil {
+		return nil
+	}
+
 	return &core.SourcePosition{
 		ZeroIndexedLineNumber:     uintLine,
 		ZeroIndexedColumnPosition: uintCol,
+		FileName:                  filename,
 	}
 }
 

pkg/spiceerrors/common.go

@@ -22,6 +22,9 @@ type WithSourceError struct {
 	// SourceCodeString is the input source code string for the error.
 	SourceCodeString string
 
+	// FileName is the filename where the error was found.
+	FileName string
+
 	// LineNumber is the (1-indexed) line number of the error, or 0 if unknown.
 	LineNumber uint64
 
@@ -42,8 +45,8 @@ func (err *WithSourceError) Unwrap() error {
 }
 
 // NewWithSourceError creates and returns a new WithSourceError.
-func NewWithSourceError(err error, sourceCodeString string, oneIndexedLineNumber uint64, oneIndexedColumnPosition uint64) *WithSourceError {
-	return &WithSourceError{err, sourceCodeString, oneIndexedLineNumber, oneIndexedColumnPosition}
+func NewWithSourceError(err error, sourceCodeString, fileName string, oneIndexedLineNumber uint64, oneIndexedColumnPosition uint64) *WithSourceError {
+	return &WithSourceError{err, sourceCodeString, fileName, oneIndexedLineNumber, oneIndexedColumnPosition}
 }
 
 // AsWithSourceError returns the error as an WithSourceError, if applicable.

pkg/validationfile/blocks/assertions.go

@@ -96,6 +96,8 @@ func (a *Assertion) UnmarshalYAML(node *yamlv3.Node) error {
 		return spiceerrors.NewWithSourceError(
 			fmt.Errorf("error parsing assertion `%s`", trimmed),
 			trimmed,
+			// TODO: this should point at the filename. is there a way to get that context here?
+			"",
 			line,
 			column,
 		)
@@ -106,6 +108,8 @@ func (a *Assertion) UnmarshalYAML(node *yamlv3.Node) error {
 		return spiceerrors.NewWithSourceError(
 			fmt.Errorf("error parsing relationship in assertion `%s`: %w", trimmed, err),
 			trimmed,
+			// TODO: this should point at the filename. is there a way to get that context here?
+			"",
 			line,
 			column,
 		)
@@ -120,6 +124,8 @@ func (a *Assertion) UnmarshalYAML(node *yamlv3.Node) error {
 			return spiceerrors.NewWithSourceError(
 				fmt.Errorf("error parsing caveat context in assertion `%s`: %w", trimmed, err),
 				trimmed,
+				// TODO: this should point at the filename. is there a way to get that context here?
+				"",
 				line,
 				column,
 			)

pkg/validationfile/blocks/errors.go

@@ -38,6 +38,8 @@ func convertYamlError(err error) error {
 		return spiceerrors.NewWithSourceError(
 			errors.New(message),
 			source,
+			// TODO: this should point at the filename. is there a way to get that context here?
+			"",
 			lineNumber,
 			0,
 		)

pkg/validationfile/blocks/expectedrelations.go

@@ -72,6 +72,8 @@ func (ors *ObjectRelation) UnmarshalYAML(node *yamlv3.Node) error {
 		return spiceerrors.NewWithSourceError(
 			fmt.Errorf("could not parse %s: %w", ors.ObjectRelationString, err),
 			ors.ObjectRelationString,
+			// TODO: this should point at the filename. is there a way to get that context here?
+			"",
 			line,
 			column,
 		)
@@ -144,6 +146,8 @@ func (es *ExpectedSubject) UnmarshalYAML(node *yamlv3.Node) error {
 		return spiceerrors.NewWithSourceError(
 			subErr,
 			subErr.SourceCodeString,
+			// TODO: this should point at the filename. is there a way to get that context here?
+			"",
 			line+subErr.LineNumber,
 			column+subErr.ColumnPosition,
 		)
@@ -154,6 +158,8 @@ func (es *ExpectedSubject) UnmarshalYAML(node *yamlv3.Node) error {
 		return spiceerrors.NewWithSourceError(
 			onrErr,
 			onrErr.SourceCodeString,
+			// TODO: this should point at the filename. is there a way to get that context here?
+			"",
 			line+onrErr.LineNumber,
 			column+onrErr.ColumnPosition,
 		)
@@ -192,13 +198,13 @@ func (vs ValidationString) Subject() (*SubjectWithExceptions, *spiceerrors.WithS
 	groups := vsSubjectWithExceptionsOrCaveatRegex.FindStringSubmatch(subjectStr)
 	if len(groups) == 0 {
 		bracketedSubjectString := "[" + subjectStr + "]"
-		return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid subject: `%s`", subjectStr), bracketedSubjectString, 0, 0)
+		return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid subject: `%s`", subjectStr), bracketedSubjectString, "", 0, 0)
 	}
 
 	subjectONRString := groups[slices.Index(vsSubjectWithExceptionsOrCaveatRegex.SubexpNames(), "subject_onr")]
 	subjectONR, err := tuple.ParseSubjectONR(subjectONRString)
 	if err != nil {
-		return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid subject: `%s`: %w", subjectONRString, err), subjectONRString, 0, 0)
+		return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid subject: `%s`: %w", subjectONRString, err), subjectONRString, "", 0, 0)
 	}
 
 	exceptionsString := strings.TrimSpace(groups[slices.Index(vsSubjectWithExceptionsOrCaveatRegex.SubexpNames(), "exceptions")])
@@ -216,7 +222,7 @@ func (vs ValidationString) Subject() (*SubjectWithExceptions, *spiceerrors.WithS
 
 			exceptionONR, err := tuple.ParseSubjectONR(strings.TrimSpace(exceptionString))
 			if err != nil {
-				return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid subject: `%s`: %w", exceptionString, err), exceptionString, 0, 0)
+				return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid subject: `%s`: %w", exceptionString, err), exceptionString, "", 0, 0)
 			}
 
 			exceptions = append(exceptions, SubjectAndCaveat{exceptionONR, isCaveated})
@@ -244,7 +250,7 @@ func (vs ValidationString) ONRS() ([]tuple.ObjectAndRelation, *spiceerrors.WithS
 	for _, onrString := range onrStrings {
 		found, err := tuple.ParseONR(onrString)
 		if err != nil {
-			return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid resource and relation: `%s`: %w", onrString, err), onrString, 0, 0)
+			return nil, spiceerrors.NewWithSourceError(fmt.Errorf("invalid resource and relation: `%s`: %w", onrString, err), onrString, "", 0, 0)
 		}
 
 		onrs = append(onrs, found)