tint: IntrinsicTable: Rename open/closed -> template

The concept of 'closing' an open type or number made sense when these
were immutable once the first type/number had been matched during
overload resolution.
In order to support abstract numerics, these template parameters need to
be constrained as the arguments are evaluated, so there's no longer a
binary open / closed state.

Give up on this concept, and rename everything to 'template type' and
'template number'. This is likely easier for people to understand
anyway.

Also fix a small typo in the ICE message printed when there's an
ambiguous overload resolution (should never happen with the current
entries in the table).

Bug: tint:1504
Change-Id: I2bf043c71e5afa757259968eae4af830c50f38e0
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/90662
Commit-Queue: Ben Clayton <bclayton@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: David Neto <dneto@google.com>

tools/src/cmd/intrinsic-gen/gen/builtin_table.go

@@ -27,39 +27,39 @@ type IntrinsicTable struct {
 	// The semantic info
 	Sem *sem.Sem
 
-	// TMatchers are all the sem.OpenType, sem.Type and sem.TypeMatchers.
+	// TMatchers are all the sem.TemplateType, sem.Type and sem.TypeMatchers.
 	// These are all implemented by classes deriving from tint::TypeMatcher
 	TMatchers     []sem.Named
 	TMatcherIndex map[sem.Named]int // [object -> index] in TMatcher
 
-	// NMatchers are all the sem.OpenNumber and sem.EnumMatchers.
+	// NMatchers are all the sem.TemplateNumber and sem.EnumMatchers.
 	// These are all implemented by classes deriving from tint::NumberMatcher
 	NMatchers     []sem.Named
 	NMatcherIndex map[sem.Named]int // [object -> index] in NMatchers
 
-	MatcherIndices            []int        // kMatcherIndices table content
-	OpenTypes                 []OpenType   // kOpenTypes table content
-	OpenNumbers               []OpenNumber // kOpenNumbers table content
-	Parameters                []Parameter  // kParameters table content
-	Overloads                 []Overload   // kOverloads table content
-	Builtins                  []Intrinsic  // kBuiltins table content
-	UnaryOperators            []Intrinsic  // kUnaryOperators table content
-	BinaryOperators           []Intrinsic  // kBinaryOperators table content
-	ConstructorsAndConverters []Intrinsic  // kConstructorsAndConverters table content
+	MatcherIndices            []int            // kMatcherIndices table content
+	TemplateTypes             []TemplateType   // kTemplateTypes table content
+	TemplateNumbers           []TemplateNumber // kTemplateNumbers table content
+	Parameters                []Parameter      // kParameters table content
+	Overloads                 []Overload       // kOverloads table content
+	Builtins                  []Intrinsic      // kBuiltins table content
+	UnaryOperators            []Intrinsic      // kUnaryOperators table content
+	BinaryOperators           []Intrinsic      // kBinaryOperators table content
+	ConstructorsAndConverters []Intrinsic      // kConstructorsAndConverters table content
 }
 
-// OpenType is used to create the C++ OpenTypeInfo structure
-type OpenType struct {
-	// Name of the open type (e.g. 'T')
+// TemplateType is used to create the C++ TemplateTypeInfo structure
+type TemplateType struct {
+	// Name of the template type (e.g. 'T')
 	Name string
 	// Optional type matcher constraint.
 	// Either an index in Matchers::type, or -1
 	MatcherIndex int
 }
 
-// OpenNumber is used to create the C++ OpenNumberInfo structure
-type OpenNumber struct {
-	// Name of the open number (e.g. 'N')
+// TemplateNumber is used to create the C++ TemplateNumberInfo structure
+type TemplateNumber struct {
+	// Name of the template number (e.g. 'N')
 	Name string
 	// Optional type matcher constraint.
 	// Either an index in Matchers::type, or -1
@@ -83,14 +83,14 @@ type Parameter struct {
 type Overload struct {
 	// Total number of parameters for the overload
 	NumParameters int
-	// Total number of open types for the overload
-	NumOpenTypes int
-	// Total number of open numbers for the overload
-	NumOpenNumbers int
-	// Index to the first open type in IntrinsicTable.OpenTypes
-	OpenTypesOffset *int
-	// Index to the first open number in IntrinsicTable.OpenNumbers
-	OpenNumbersOffset *int
+	// Total number of template types for the overload
+	NumTemplateTypes int
+	// Total number of template numbers for the overload
+	NumTemplateNumbers int
+	// Index to the first template type in IntrinsicTable.TemplateTypes
+	TemplateTypesOffset *int
+	// Index to the first template number in IntrinsicTable.TemplateNumbers
+	TemplateNumbersOffset *int
 	// Index to the first parameter in IntrinsicTable.Parameters
 	ParametersOffset *int
 	// Index into IntrinsicTable.MatcherIndices, beginning the list of matchers
@@ -123,25 +123,25 @@ type IntrinsicTableBuilder struct {
 	// Lookup tables.
 	// These are packed (compressed) once all the entries have been added.
 	lut struct {
-		matcherIndices lut.LUT
-		openTypes      lut.LUT
-		openNumbers    lut.LUT
-		parameters     lut.LUT
-		overloads      lut.LUT
+		matcherIndices  lut.LUT
+		templateTypes   lut.LUT
+		templateNumbers lut.LUT
+		parameters      lut.LUT
+		overloads       lut.LUT
 	}
 }
 
 // Helper for building a single overload
 type overloadBuilder struct {
 	*IntrinsicTableBuilder
-	// Maps TemplateParam to index in openTypes
-	openTypeIndex map[sem.TemplateParam]int
-	// Maps TemplateParam to index in openNumbers
-	openNumberIndex map[sem.TemplateParam]int
-	// Open types used by the overload
-	openTypes []OpenType
-	// Open numbers used by the overload
-	openNumbers []OpenNumber
+	// Maps TemplateParam to index in templateTypes
+	templateTypeIndex map[sem.TemplateParam]int
+	// Maps TemplateParam to index in templateNumbers
+	templateNumberIndex map[sem.TemplateParam]int
+	// Template types used by the overload
+	templateTypes []TemplateType
+	// Template numbers used by the overload
+	templateNumbers []TemplateNumber
 	// All parameters declared by the overload
 	parameters []Parameter
 	// Index into IntrinsicTable.MatcherIndices, beginning the list of matchers
@@ -155,8 +155,8 @@ type overloadBuilder struct {
 // layoutMatchers assigns each of the TMatchers and NMatchers a unique index
 // in the C++ Matchers::type and Matchers::number arrays, respectively.
 func (b *IntrinsicTableBuilder) layoutMatchers(s *sem.Sem) {
-	// First MaxOpenTypes of TMatchers are open types
-	b.TMatchers = make([]sem.Named, s.MaxOpenTypes)
+	// First MaxTemplateTypes of TMatchers are template types
+	b.TMatchers = make([]sem.Named, s.MaxTemplateTypes)
 	for _, m := range s.Types {
 		b.TMatcherIndex[m] = len(b.TMatchers)
 		b.TMatchers = append(b.TMatchers, m)
@@ -166,8 +166,8 @@ func (b *IntrinsicTableBuilder) layoutMatchers(s *sem.Sem) {
 		b.TMatchers = append(b.TMatchers, m)
 	}
 
-	// First MaxOpenNumbers of NMatchers are open numbers
-	b.NMatchers = make([]sem.Named, s.MaxOpenNumbers)
+	// First MaxTemplateNumbers of NMatchers are template numbers
+	b.NMatchers = make([]sem.Named, s.MaxTemplateNumbers)
 	for _, m := range s.EnumMatchers {
 		b.NMatcherIndex[m] = len(b.NMatchers)
 		b.NMatchers = append(b.NMatchers, m)
@@ -178,14 +178,14 @@ func (b *IntrinsicTableBuilder) layoutMatchers(s *sem.Sem) {
 func (b *IntrinsicTableBuilder) buildOverload(o *sem.Overload) (Overload, error) {
 	ob := overloadBuilder{
 		IntrinsicTableBuilder: b,
-		openTypeIndex:         map[sem.TemplateParam]int{},
-		openNumberIndex:       map[sem.TemplateParam]int{},
+		templateTypeIndex:     map[sem.TemplateParam]int{},
+		templateNumberIndex:   map[sem.TemplateParam]int{},
 	}
 
-	if err := ob.buildOpenTypes(o); err != nil {
+	if err := ob.buildTemplateTypes(o); err != nil {
 		return Overload{}, err
 	}
-	if err := ob.buildOpenNumbers(o); err != nil {
+	if err := ob.buildTemplateNumbers(o); err != nil {
 		return Overload{}, err
 	}
 	if err := ob.buildParameters(o); err != nil {
@@ -197,10 +197,10 @@ func (b *IntrinsicTableBuilder) buildOverload(o *sem.Overload) (Overload, error)
 
 	return Overload{
 		NumParameters:              len(ob.parameters),
-		NumOpenTypes:               len(ob.openTypes),
-		NumOpenNumbers:             len(ob.openNumbers),
-		OpenTypesOffset:            b.lut.openTypes.Add(ob.openTypes),
-		OpenNumbersOffset:          b.lut.openNumbers.Add(ob.openNumbers),
+		NumTemplateTypes:           len(ob.templateTypes),
+		NumTemplateNumbers:         len(ob.templateNumbers),
+		TemplateTypesOffset:        b.lut.templateTypes.Add(ob.templateTypes),
+		TemplateNumbersOffset:      b.lut.templateNumbers.Add(ob.templateNumbers),
 		ParametersOffset:           b.lut.parameters.Add(ob.parameters),
 		ReturnMatcherIndicesOffset: ob.returnTypeMatcherIndicesOffset,
 		CanBeUsedInStage:           o.CanBeUsedInStage,
@@ -209,12 +209,12 @@ func (b *IntrinsicTableBuilder) buildOverload(o *sem.Overload) (Overload, error)
 	}, nil
 }
 
-// buildOpenTypes constructs the OpenTypes used by the overload, populating
-// b.openTypes
-func (b *overloadBuilder) buildOpenTypes(o *sem.Overload) error {
-	b.openTypes = make([]OpenType, len(o.OpenTypes))
-	for i, t := range o.OpenTypes {
-		b.openTypeIndex[t] = i
+// buildTemplateTypes constructs the TemplateTypes used by the overload, populating
+// b.templateTypes
+func (b *overloadBuilder) buildTemplateTypes(o *sem.Overload) error {
+	b.templateTypes = make([]TemplateType, len(o.TemplateTypes))
+	for i, t := range o.TemplateTypes {
+		b.templateTypeIndex[t] = i
 		matcherIndex := -1
 		if t.Type != nil {
 			var err error
@@ -223,7 +223,7 @@ func (b *overloadBuilder) buildOpenTypes(o *sem.Overload) error {
 				return err
 			}
 		}
-		b.openTypes[i] = OpenType{
+		b.templateTypes[i] = TemplateType{
 			Name:         t.Name,
 			MatcherIndex: matcherIndex,
 		}
@@ -231,12 +231,12 @@ func (b *overloadBuilder) buildOpenTypes(o *sem.Overload) error {
 	return nil
 }
 
-// buildOpenNumbers constructs the OpenNumbers used by the overload, populating
-// b.openNumbers
-func (b *overloadBuilder) buildOpenNumbers(o *sem.Overload) error {
-	b.openNumbers = make([]OpenNumber, len(o.OpenNumbers))
-	for i, t := range o.OpenNumbers {
-		b.openNumberIndex[t] = i
+// buildTemplateNumbers constructs the TemplateNumbers used by the overload, populating
+// b.templateNumbers
+func (b *overloadBuilder) buildTemplateNumbers(o *sem.Overload) error {
+	b.templateNumbers = make([]TemplateNumber, len(o.TemplateNumbers))
+	for i, t := range o.TemplateNumbers {
+		b.templateNumberIndex[t] = i
 		matcherIndex := -1
 		if e, ok := t.(*sem.TemplateEnumParam); ok && e.Matcher != nil {
 			var err error
@@ -245,7 +245,7 @@ func (b *overloadBuilder) buildOpenNumbers(o *sem.Overload) error {
 				return err
 			}
 		}
-		b.openNumbers[i] = OpenNumber{
+		b.templateNumbers[i] = TemplateNumber{
 			Name:         t.GetName(),
 			MatcherIndex: matcherIndex,
 		}
@@ -295,25 +295,25 @@ func (b *overloadBuilder) matcherIndex(n sem.Named) (int, error) {
 		}
 		return 0, fmt.Errorf("matcherIndex missing entry for %v %T", n.GetName(), n)
 	case *sem.TemplateTypeParam:
-		if i, ok := b.openTypeIndex[n]; ok {
+		if i, ok := b.templateTypeIndex[n]; ok {
 			return i, nil
 		}
-		return 0, fmt.Errorf("openTypeIndex missing entry for %v %T", n.Name, n)
+		return 0, fmt.Errorf("templateTypeIndex missing entry for %v %T", n.Name, n)
 	case *sem.EnumMatcher:
 		if i, ok := b.NMatcherIndex[n]; ok {
 			return i, nil
 		}
 		return 0, fmt.Errorf("matcherIndex missing entry for %v %T", n.GetName(), n)
 	case *sem.TemplateEnumParam:
-		if i, ok := b.openNumberIndex[n]; ok {
+		if i, ok := b.templateNumberIndex[n]; ok {
 			return i, nil
 		}
-		return 0, fmt.Errorf("openNumberIndex missing entry for %v %T", n, n)
+		return 0, fmt.Errorf("templateNumberIndex missing entry for %v %T", n, n)
 	case *sem.TemplateNumberParam:
-		if i, ok := b.openNumberIndex[n]; ok {
+		if i, ok := b.templateNumberIndex[n]; ok {
 			return i, nil
 		}
-		return 0, fmt.Errorf("openNumberIndex missing entry for %v %T", n, n)
+		return 0, fmt.Errorf("templateNumberIndex missing entry for %v %T", n, n)
 	default:
 		return 0, fmt.Errorf("overload.matcherIndex() does not handle %v %T", n, n)
 	}
@@ -359,8 +359,8 @@ func buildIntrinsicTable(s *sem.Sem) (*IntrinsicTable, error) {
 		},
 	}
 	b.lut.matcherIndices = lut.New(list.Wrap(&b.MatcherIndices))
-	b.lut.openTypes = lut.New(list.Wrap(&b.OpenTypes))
-	b.lut.openNumbers = lut.New(list.Wrap(&b.OpenNumbers))
+	b.lut.templateTypes = lut.New(list.Wrap(&b.TemplateTypes))
+	b.lut.templateNumbers = lut.New(list.Wrap(&b.TemplateNumbers))
 	b.lut.parameters = lut.New(list.Wrap(&b.Parameters))
 	b.lut.overloads = lut.New(list.Wrap(&b.Overloads))
 
@@ -397,8 +397,8 @@ func buildIntrinsicTable(s *sem.Sem) (*IntrinsicTable, error) {
 	}
 
 	b.lut.matcherIndices.Compact()
-	b.lut.openTypes.Compact()
-	b.lut.openNumbers.Compact()
+	b.lut.templateTypes.Compact()
+	b.lut.templateNumbers.Compact()
 	b.lut.parameters.Compact()
 	b.lut.overloads.Compact()
 

tools/src/cmd/intrinsic-gen/gen/permutate.go

@@ -32,7 +32,7 @@ type Permuter struct {
 
 // buildPermuter returns a new initialized Permuter
 func buildPermuter(s *sem.Sem) (*Permuter, error) {
-	// allTypes are the list of FQNs that are used for open, unconstrained types
+	// allTypes are the list of FQNs that are used for unconstrained types
 	allTypes := []sem.FullyQualifiedName{}
 	for _, ty := range s.Types {
 		if len(ty.TemplateParams) > 0 {
@@ -58,10 +58,10 @@ type Permutation struct {
 // Permute generates a set of permutations for the given intrinsic overload
 func (p *Permuter) Permute(overload *sem.Overload) ([]Permutation, error) {
 	state := permutationState{
-		Permuter:      p,
-		closedTypes:   map[sem.TemplateParam]sem.FullyQualifiedName{},
-		closedNumbers: map[sem.TemplateParam]interface{}{},
-		parameters:    map[int]sem.FullyQualifiedName{},
+		Permuter:        p,
+		templateTypes:   map[sem.TemplateParam]sem.FullyQualifiedName{},
+		templateNumbers: map[sem.TemplateParam]interface{}{},
+		parameters:      map[int]sem.FullyQualifiedName{},
 	}
 
 	out := []Permutation{}
@@ -144,15 +144,15 @@ func (p *Permuter) Permute(overload *sem.Overload) ([]Permutation, error) {
 				var err error
 				types, err = state.permutateFQN(sem.FullyQualifiedName{Target: t.Type})
 				if err != nil {
-					return nil, fmt.Errorf("while permutating open types: %w", err)
+					return nil, fmt.Errorf("while permutating template types: %w", err)
 				}
 			}
 			if len(types) == 0 {
-				return nil, fmt.Errorf("open type %v has no permutations", t.Name)
+				return nil, fmt.Errorf("template type %v has no permutations", t.Name)
 			}
 			permutate = func() error {
 				for _, ty := range types {
-					state.closedTypes[t] = ty
+					state.templateTypes[t] = ty
 					if err := next(); err != nil {
 						return err
 					}
@@ -168,14 +168,14 @@ func (p *Permuter) Permute(overload *sem.Overload) ([]Permutation, error) {
 				permutations, err = state.permutateFQN(sem.FullyQualifiedName{Target: t.Enum})
 			}
 			if err != nil {
-				return nil, fmt.Errorf("while permutating open numbers: %w", err)
+				return nil, fmt.Errorf("while permutating template numbers: %w", err)
 			}
 			if len(permutations) == 0 {
-				return nil, fmt.Errorf("open type %v has no permutations", t.Name)
+				return nil, fmt.Errorf("template type %v has no permutations", t.Name)
 			}
 			permutate = func() error {
 				for _, n := range permutations {
-					state.closedNumbers[t] = n
+					state.templateNumbers[t] = n
 					if err := next(); err != nil {
 						return err
 					}
@@ -187,7 +187,7 @@ func (p *Permuter) Permute(overload *sem.Overload) ([]Permutation, error) {
 			permutations := []int{2, 3, 4}
 			permutate = func() error {
 				for _, n := range permutations {
-					state.closedNumbers[t] = n
+					state.templateNumbers[t] = n
 					if err := next(); err != nil {
 						return err
 					}
@@ -206,19 +206,19 @@ func (p *Permuter) Permute(overload *sem.Overload) ([]Permutation, error) {
 
 type permutationState struct {
 	*Permuter
-	closedTypes   map[sem.TemplateParam]sem.FullyQualifiedName
-	closedNumbers map[sem.TemplateParam]interface{}
-	parameters    map[int]sem.FullyQualifiedName
+	templateTypes   map[sem.TemplateParam]sem.FullyQualifiedName
+	templateNumbers map[sem.TemplateParam]interface{}
+	parameters      map[int]sem.FullyQualifiedName
 }
 
 func (s permutationState) String() string {
 	sb := &strings.Builder{}
-	sb.WriteString("Closed types:\n")
-	for ct, ty := range s.closedTypes {
+	sb.WriteString("Template types:\n")
+	for ct, ty := range s.templateTypes {
 		fmt.Fprintf(sb, "  %v: %v\n", ct.GetName(), ty)
 	}
-	sb.WriteString("Closed numbers:\n")
-	for cn, v := range s.closedNumbers {
+	sb.WriteString("Template numbers:\n")
+	for cn, v := range s.templateNumbers {
 		fmt.Fprintf(sb, "  %v: %v\n", cn.GetName(), v)
 	}
 	return sb.String()
@@ -240,13 +240,13 @@ func (s *permutationState) permutateFQN(in sem.FullyQualifiedName) ([]sem.FullyQ
 			return nil
 		}
 	case sem.TemplateParam:
-		if ty, ok := s.closedTypes[target]; ok {
+		if ty, ok := s.templateTypes[target]; ok {
 			permutate = func() error {
 				out = append(out, ty)
 				return nil
 			}
 		} else {
-			return nil, fmt.Errorf("'%v' was not found in closedTypes", target.GetName())
+			return nil, fmt.Errorf("'%v' was not found in templateTypes", target.GetName())
 		}
 	case *sem.TypeMatcher:
 		permutate = func() error {
@@ -284,12 +284,12 @@ func (s *permutationState) permutateFQN(in sem.FullyQualifiedName) ([]sem.FullyQ
 		case sem.FullyQualifiedName:
 			switch target := arg.Target.(type) {
 			case sem.TemplateParam:
-				if ty, ok := s.closedTypes[target]; ok {
+				if ty, ok := s.templateTypes[target]; ok {
 					args[i] = ty
-				} else if num, ok := s.closedNumbers[target]; ok {
+				} else if num, ok := s.templateNumbers[target]; ok {
 					args[i] = num
 				} else {
-					return nil, fmt.Errorf("'%v' was not found in closedTypes or closedNumbers", target.GetName())
+					return nil, fmt.Errorf("'%v' was not found in templateTypes or templateNumbers", target.GetName())
 				}
 			default:
 				perms, err := s.permutateFQN(arg)

tools/src/cmd/intrinsic-gen/resolver/resolve.go

@@ -328,22 +328,22 @@ func (r *resolver) intrinsic(
 	intrinsic.Overloads = append(intrinsic.Overloads, overload)
 
 	// Sort the template parameters by resolved type. Append these to
-	// sem.Overload.OpenTypes or sem.Overload.OpenNumbers based on their kind.
+	// sem.Overload.TemplateTypes or sem.Overload.TemplateNumbers based on their kind.
 	for _, param := range templateParams {
 		switch param := param.(type) {
 		case *sem.TemplateTypeParam:
-			overload.OpenTypes = append(overload.OpenTypes, param)
+			overload.TemplateTypes = append(overload.TemplateTypes, param)
 		case *sem.TemplateEnumParam, *sem.TemplateNumberParam:
-			overload.OpenNumbers = append(overload.OpenNumbers, param)
+			overload.TemplateNumbers = append(overload.TemplateNumbers, param)
 		}
 	}
 
-	// Update high-water marks of open types / numbers
-	if r.s.MaxOpenTypes < len(overload.OpenTypes) {
-		r.s.MaxOpenTypes = len(overload.OpenTypes)
+	// Update high-water marks of template types and numbers
+	if r.s.MaxTemplateTypes < len(overload.TemplateTypes) {
+		r.s.MaxTemplateTypes = len(overload.TemplateTypes)
 	}
-	if r.s.MaxOpenNumbers < len(overload.OpenNumbers) {
-		r.s.MaxOpenNumbers = len(overload.OpenNumbers)
+	if r.s.MaxTemplateNumbers < len(overload.TemplateNumbers) {
+		r.s.MaxTemplateNumbers = len(overload.TemplateNumbers)
 	}
 
 	// Resolve the parameters

tools/src/cmd/intrinsic-gen/sem/sem.go

@@ -30,10 +30,10 @@ type Sem struct {
 	UnaryOperators            []*Intrinsic
 	BinaryOperators           []*Intrinsic
 	ConstructorsAndConverters []*Intrinsic
-	// Maximum number of open-types used across all builtins
-	MaxOpenTypes int
-	// Maximum number of open-numbers used across all builtins
-	MaxOpenNumbers int
+	// Maximum number of template types used across all builtins
+	MaxTemplateTypes int
+	// Maximum number of template numbers used across all builtins
+	MaxTemplateNumbers int
 	// The alphabetically sorted list of unique parameter names
 	UniqueParameterNames []string
 }
@@ -137,8 +137,8 @@ type Overload struct {
 	Decl             ast.IntrinsicDecl
 	Intrinsic        *Intrinsic
 	TemplateParams   []TemplateParam
-	OpenTypes        []*TemplateTypeParam
-	OpenNumbers      []TemplateParam
+	TemplateTypes    []*TemplateTypeParam
+	TemplateNumbers  []TemplateParam
 	ReturnType       *FullyQualifiedName
 	Parameters       []Parameter
 	CanBeUsedInStage StageUses