internal/filetypes: clarify FromFile

Currently it's not entirely clear which parts of the build.File are used
by FromFile to feed into the resulting FileInfo. Make the logic clearer
by unifying only the encoding, form, and interpretation fields, making
it obvious that the tags do not play any role here, and this implying
that the number of possible inputs are more limited than those to
toFile.

Also make it clear that the subsidiary tags are not expected to be an
output of `FromFile` by inlining only those parts of `build.File` which
are actually used. This does not affect behavior because nothing
actually uses those fields.

Also require the Encoding field, as documented, which requires some test
changes, but this should have no overall effect because the file passed
into FromFile has invariably come originally from toFile (e.g. via
ParseArgs) and that will fill in the Encoding field. Thus none of the
cmd/cue tests fail as a result.

Also remove a TODO that seems unlikely to be possible to do, as the
current mode _can_ influence various FileInfo fields, and that doesn't
necessarily seem like a bad thing.

Also, change the "handle common case" code to return the actual Form
returned by the underlying logic that this is optimized from: when
checking the "emulated" version for discrepancies in a subsequent CL, it
became clear that this was the correct behavior.

For #3280.

Signed-off-by: Roger Peppe <[email protected]>
Change-Id: Icbb54b544469002ea08710fa585177dada38c974
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1213873
Unity-Result: CUE porcuepine <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>
Reviewed-by: Daniel Martí <[email protected]>

Author: rogpeppe

internal/filetypes/filetypes.go

@@ -19,9 +19,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
-	"sync"
 
-	"cuelang.org/go/cue"
 	"cuelang.org/go/cue/build"
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
@@ -53,7 +51,10 @@ func (m Mode) String() string {
 
 // FileInfo defines the parsing plan for a file.
 type FileInfo struct {
-	*build.File
+	Filename       string               `json:"filename"`
+	Encoding       build.Encoding       `json:"encoding,omitempty"`
+	Interpretation build.Interpretation `json:"interpretation,omitempty"`
+	Form           build.Form           `json:"form,omitempty"`
 
 	Definitions  bool `json:"definitions"`  // include/allow definition fields
 	Data         bool `json:"data"`         // include/allow regular fields
@@ -69,88 +70,6 @@ type FileInfo struct {
 	Attributes   bool `json:"attributes"`   // include/allow attributes
 }
 
-// evalMu guards against concurrent execution of the CUE evaluator.
-// See issue https://cuelang.org/issue/2733
-var evalMu sync.Mutex
-
-// TODO(mvdan): the funcs below make use of typesValue concurrently,
-// even though we clearly document that cue.Values are not safe for concurrent use.
-// It seems to be OK in practice, as otherwise we would run into `go test -race` failures.
-
-// FromFile return detailed file info for a given build file.
-// Encoding must be specified.
-// TODO: mode should probably not be necessary here.
-func FromFile(b *build.File, mode Mode) (*FileInfo, error) {
-	// Handle common case. This allows certain test cases to be analyzed in
-	// isolation without interference from evaluating these files.
-	if mode == Input &&
-		b.Encoding == build.CUE &&
-		b.Form == "" &&
-		b.Interpretation == "" {
-		return &FileInfo{
-			File: b,
-
-			Definitions:  true,
-			Data:         true,
-			Optional:     true,
-			Constraints:  true,
-			References:   true,
-			Cycles:       true,
-			KeepDefaults: true,
-			Incomplete:   true,
-			Imports:      true,
-			Docs:         true,
-			Attributes:   true,
-		}, nil
-	}
-	evalMu.Lock()
-	defer evalMu.Unlock()
-	typesInit()
-	modeVal := lookup(typesValue, "modes", mode.String())
-	fileVal := lookup(modeVal, "FileInfo")
-	fileVal = fileVal.FillPath(cue.Path{}, b)
-
-	if b.Encoding == "" {
-		ext := lookup(modeVal, "extensions", fileExt(b.Filename))
-		if ext.Exists() {
-			fileVal = fileVal.Unify(ext)
-		}
-	}
-	var errs errors.Error
-
-	interpretation, _ := lookup(fileVal, "interpretation").String()
-	if b.Form != "" {
-		fileVal, errs = unifyWith(errs, fileVal, typesValue, "forms", string(b.Form))
-		// may leave some encoding-dependent options open in data mode.
-	} else if interpretation != "" {
-		// always sets form=*schema
-		fileVal, errs = unifyWith(errs, fileVal, typesValue, "interpretations", interpretation)
-	}
-	if interpretation == "" {
-		s, err := lookup(fileVal, "encoding").String()
-		if err != nil {
-			return nil, err
-		}
-		fileVal, errs = unifyWith(errs, fileVal, modeVal, "encodings", s)
-	}
-
-	fi := &FileInfo{}
-	if err := fileVal.Decode(fi); err != nil {
-		return nil, errors.Wrapf(err, token.NoPos, "could not parse arguments")
-	}
-	return fi, errs
-}
-
-// unifyWith returns the equivalent of `v1 & v2[field][value]`.
-func unifyWith(errs errors.Error, v1, v2 cue.Value, field, value string) (cue.Value, errors.Error) {
-	v1 = v1.Unify(lookup(v2, field, value))
-	if err := v1.Err(); err != nil {
-		errs = errors.Append(errs,
-			errors.Newf(token.NoPos, "unknown %s %s", field, value))
-	}
-	return v1, errs
-}
-
 // ParseArgs converts a sequence of command line arguments representing
 // files into a sequence of build file specifications.
 //
@@ -307,60 +226,6 @@ func ParseFileAndType(file, scope string, mode Mode) (*build.File, error) {
 	return toFile(mode, sc, file)
 }
 
-func hasEncoding(v cue.Value) bool {
-	return lookup(v, "encoding").Exists()
-}
-
-func toFile(mode Mode, sc *scope, filename string) (*build.File, error) {
-	modeVal := lookup(typesValue, "modes", mode.String())
-	fileVal := lookup(modeVal, "FileInfo")
-
-	for tagName := range sc.topLevel {
-		info := lookup(typesValue, "tagInfo", tagName)
-		if info.Exists() {
-			fileVal = fileVal.Unify(info)
-		} else {
-			return nil, errors.Newf(token.NoPos, "unknown filetype %s", tagName)
-		}
-	}
-	allowedSubsidiaryBool := lookup(fileVal, "boolTags")
-	for tagName, val := range sc.subsidiaryBool {
-		if !lookup(allowedSubsidiaryBool, tagName).Exists() {
-			return nil, errors.Newf(token.NoPos, "tag %s is not allowed in this context", tagName)
-		}
-		fileVal = fileVal.FillPath(cue.MakePath(cue.Str("boolTags"), cue.Str(tagName)), val)
-	}
-	allowedSubsidiaryString := lookup(fileVal, "tags")
-	for tagName, val := range sc.subsidiaryString {
-		if !lookup(allowedSubsidiaryString, tagName).Exists() {
-			return nil, errors.Newf(token.NoPos, "tag %s is not allowed in this context", tagName)
-		}
-		fileVal = fileVal.FillPath(cue.MakePath(cue.Str("tags"), cue.Str(tagName)), val)
-	}
-	if !hasEncoding(fileVal) {
-		if filename == "-" {
-			fileVal = fileVal.Unify(lookup(modeVal, "Default"))
-		} else if ext := fileExt(filename); ext != "" {
-			extFile := lookup(modeVal, "extensions", ext)
-			if !extFile.Exists() {
-				return nil, errors.Newf(token.NoPos, "unknown file extension %s", ext)
-			}
-			fileVal = fileVal.Unify(extFile)
-		} else {
-			return nil, errors.Newf(token.NoPos, "no encoding specified for file %q", filename)
-		}
-	}
-
-	// Note that the filename is only filled in the Go value, and not the CUE value.
-	// This makes no difference to the logic, but saves a non-trivial amount of evaluator work.
-	f := &build.File{Filename: filename}
-	if err := fileVal.Decode(&f); err != nil {
-		return nil, errors.Wrapf(err, token.NoPos,
-			"could not determine file type")
-	}
-	return f, nil
-}
-
 // scope holds attributes that influence encoding and decoding.
 // Together with the mode and the file name, they determine
 // a number of properties of the encoding process.
@@ -430,31 +295,3 @@ func seqConcat[T any](iters ...iter.Seq[T]) iter.Seq[T] {
 		}
 	}
 }
-
-// lookup looks up the given string field path in v.
-func lookup(v cue.Value, elems ...string) cue.Value {
-	sels := make([]cue.Selector, len(elems))
-	for i := range elems {
-		sels[i] = cue.Str(elems[i])
-	}
-	return v.LookupPath(cue.MakePath(sels...))
-}
-
-// structFields returns an iterator over the names of all the regulat fields
-// in v and their values.
-func structFields(v cue.Value) iter.Seq2[string, cue.Value] {
-	return func(yield func(string, cue.Value) bool) {
-		if !v.Exists() {
-			return
-		}
-		iter, err := v.Fields()
-		if err != nil {
-			return
-		}
-		for iter.Next() {
-			if !yield(iter.Selector().Unquoted(), iter.Value()) {
-				break
-			}
-		}
-	}
-}