tint: Update constructor / conversion terminology

Rename:
* "type initializer" -> "value constructor"
* "type conversion" -> "value conversion"

Fixed: tint:1848
Change-Id: I3e86a4e944971cea970f0d137641517c36cb807d
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/121060
Auto-Submit: Ben Clayton <bclayton@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>

tools/src/tint/intrinsic/ast/ast.go

@@ -29,7 +29,7 @@ type AST struct {
 	Types        []TypeDecl
 	Matchers     []MatcherDecl
 	Builtins     []IntrinsicDecl
-	Initializers []IntrinsicDecl
+	Constructors []IntrinsicDecl
 	Converters   []IntrinsicDecl
 	Operators    []IntrinsicDecl
 }
@@ -52,7 +52,7 @@ func (a AST) String() string {
 		fmt.Fprintf(&sb, "%v", b)
 		fmt.Fprintln(&sb)
 	}
-	for _, o := range a.Initializers {
+	for _, o := range a.Constructors {
 		fmt.Fprintf(&sb, "%v", o)
 		fmt.Fprintln(&sb)
 	}
@@ -123,10 +123,10 @@ const (
 	// Operator is a unary or binary operator.
 	// Declared with 'op'.
 	Operator IntrinsicKind = "operator"
-	// Initializer is a type initializer function.
+	// Constructor is a value constructor function.
 	// Declared with 'init'.
-	Initializer IntrinsicKind = "initializer"
-	// Converter is a type conversion function.
+	Constructor IntrinsicKind = "constructor"
+	// Converter is a value conversion function.
 	// Declared with 'conv'.
 	Converter IntrinsicKind = "converter"
 )
@@ -149,8 +149,8 @@ func (i IntrinsicDecl) Format(w fmt.State, verb rune) {
 		fmt.Fprintf(w, "fn ")
 	case Operator:
 		fmt.Fprintf(w, "op ")
-	case Initializer:
-		fmt.Fprintf(w, "init ")
+	case Constructor:
+		fmt.Fprintf(w, "ctor ")
 	case Converter:
 		fmt.Fprintf(w, "conv ")
 	}

tools/src/tint/intrinsic/gen/gen.go

@@ -50,7 +50,7 @@ type IntrinsicTable struct {
 	Builtins                  []Intrinsic      // kBuiltins table content
 	UnaryOperators            []Intrinsic      // kUnaryOperators table content
 	BinaryOperators           []Intrinsic      // kBinaryOperators table content
-	InitializersAndConverters []Intrinsic      // kInitializersAndConverters table content
+	ConstructorsAndConverters []Intrinsic      // kInitializersAndConverters table content
 }
 
 // TemplateType is used to create the C++ TemplateTypeInfo structure
@@ -387,7 +387,7 @@ func BuildIntrinsicTable(s *sem.Sem) (*IntrinsicTable, error) {
 		{s.Builtins, &b.Builtins},
 		{s.UnaryOperators, &b.UnaryOperators},
 		{s.BinaryOperators, &b.BinaryOperators},
-		{s.InitializersAndConverters, &b.InitializersAndConverters},
+		{s.ConstructorsAndConverters, &b.ConstructorsAndConverters},
 	} {
 		out := make([]Intrinsic, len(intrinsics.in))
 		for i, f := range intrinsics.in {

tools/src/tint/intrinsic/lexer/lexer.go

@@ -104,8 +104,8 @@ func (l *lexer) lex() error {
 					l.tok(n, tok.Enum)
 				case "type":
 					l.tok(n, tok.Type)
-				case "init":
-					l.tok(n, tok.Initializer)
+				case "ctor":
+					l.tok(n, tok.Constructor)
 				case "conv":
 					l.tok(n, tok.Converter)
 				case "match":

tools/src/tint/intrinsic/lexer/lexer_test.go

@@ -90,7 +90,7 @@ func TestLexTokens(t *testing.T) {
 		{"type", []tok.Token{{Kind: tok.Type, Runes: []rune("type"), Source: tok.Source{
 			S: loc(1, 1, 0), E: loc(1, 5, 4),
 		}}}},
-		{"init", []tok.Token{{Kind: tok.Initializer, Runes: []rune("init"), Source: tok.Source{
+		{"ctor", []tok.Token{{Kind: tok.Constructor, Runes: []rune("ctor"), Source: tok.Source{
 			S: loc(1, 1, 0), E: loc(1, 5, 4),
 		}}}},
 		{"conv", []tok.Token{{Kind: tok.Converter, Runes: []rune("conv"), Source: tok.Source{

tools/src/tint/intrinsic/parser/parser.go

@@ -72,8 +72,8 @@ func (p *parser) parse() (*ast.AST, error) {
 		case tok.Operator:
 			out.Operators = append(out.Operators, p.operatorDecl(attributes))
 			attributes = nil
-		case tok.Initializer:
-			out.Initializers = append(out.Initializers, p.initializerDecl(attributes))
+		case tok.Constructor:
+			out.Constructors = append(out.Constructors, p.constructorDecl(attributes))
 			attributes = nil
 		case tok.Converter:
 			out.Converters = append(out.Converters, p.converterDecl(attributes))
@@ -221,12 +221,12 @@ func (p *parser) operatorDecl(decos ast.Attributes) ast.IntrinsicDecl {
 	return f
 }
 
-func (p *parser) initializerDecl(decos ast.Attributes) ast.IntrinsicDecl {
-	p.expect(tok.Initializer, "initializer declaration")
+func (p *parser) constructorDecl(decos ast.Attributes) ast.IntrinsicDecl {
+	p.expect(tok.Constructor, "constructor declaration")
 	name := p.next()
 	f := ast.IntrinsicDecl{
 		Source:     name.Source,
-		Kind:       ast.Initializer,
+		Kind:       ast.Constructor,
 		Attributes: decos,
 		Name:       string(name.Runes),
 	}

tools/src/tint/intrinsic/parser/parser_test.go

@@ -440,20 +440,20 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F()",
+			"ctor F()",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind:       ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind:       ast.Constructor,
 					Name:       "F",
 					Parameters: ast.Parameters{},
 				}},
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"@attr init F()",
+			"@attr ctor F()",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					Attributes: ast.Attributes{
 						{Name: "attr", Values: nil},
@@ -463,10 +463,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F(a)",
+			"ctor F(a)",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					Parameters: ast.Parameters{
 						{Type: ast.TemplatedName{Name: "a"}},
@@ -475,10 +475,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F(a: T)",
+			"ctor F(a: T)",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					Parameters: ast.Parameters{
 						{Name: "a", Type: ast.TemplatedName{Name: "T"}},
@@ -487,10 +487,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F(a, b)",
+			"ctor F(a, b)",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					Parameters: ast.Parameters{
 						{Type: ast.TemplatedName{Name: "a"}},
@@ -500,10 +500,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F<A : B<C> >()",
+			"ctor F<A : B<C> >()",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					TemplateParams: ast.TemplateParams{
 						{
@@ -520,10 +520,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F<T>(a: X, b: Y<T>)",
+			"ctor F<T>(a: X, b: Y<T>)",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					TemplateParams: ast.TemplateParams{
 						{Name: "T"},
@@ -539,10 +539,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F() -> X",
+			"ctor F() -> X",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind:       ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind:       ast.Constructor,
 					Name:       "F",
 					ReturnType: &ast.TemplatedName{Name: "X"},
 					Parameters: ast.Parameters{},
@@ -550,10 +550,10 @@ func TestParser(t *testing.T) {
 			},
 		}, { ///////////////////////////////////////////////////////////////////
 			fileutils.ThisLine(),
-			"init F() -> X<T>",
+			"ctor F() -> X<T>",
 			ast.AST{
-				Initializers: []ast.IntrinsicDecl{{
-					Kind: ast.Initializer,
+				Constructors: []ast.IntrinsicDecl{{
+					Kind: ast.Constructor,
 					Name: "F",
 					ReturnType: &ast.TemplatedName{
 						Name:         "X",

tools/src/tint/intrinsic/resolver/resolve.go

@@ -32,7 +32,7 @@ type resolver struct {
 	builtins                  map[string]*sem.Intrinsic
 	unaryOperators            map[string]*sem.Intrinsic
 	binaryOperators           map[string]*sem.Intrinsic
-	initializersAndConverters map[string]*sem.Intrinsic
+	constructorsAndConverters map[string]*sem.Intrinsic
 	enumEntryMatchers         map[*sem.EnumEntry]*sem.EnumMatcher
 }
 
@@ -45,7 +45,7 @@ func Resolve(a *ast.AST) (*sem.Sem, error) {
 		builtins:                  map[string]*sem.Intrinsic{},
 		unaryOperators:            map[string]*sem.Intrinsic{},
 		binaryOperators:           map[string]*sem.Intrinsic{},
-		initializersAndConverters: map[string]*sem.Intrinsic{},
+		constructorsAndConverters: map[string]*sem.Intrinsic{},
 		enumEntryMatchers:         map[*sem.EnumEntry]*sem.EnumMatcher{},
 	}
 	// Declare and resolve all the enumerators
@@ -88,9 +88,9 @@ func Resolve(a *ast.AST) (*sem.Sem, error) {
 		}
 	}
 
-	// Declare and resolve type initializers and converters
-	for _, c := range a.Initializers {
-		if err := r.intrinsic(c, r.initializersAndConverters, &r.s.InitializersAndConverters); err != nil {
+	// Declare and resolve value constructors and converters
+	for _, c := range a.Constructors {
+		if err := r.intrinsic(c, r.constructorsAndConverters, &r.s.ConstructorsAndConverters); err != nil {
 			return nil, err
 		}
 	}
@@ -98,7 +98,7 @@ func Resolve(a *ast.AST) (*sem.Sem, error) {
 		if len(c.Parameters) != 1 {
 			return nil, fmt.Errorf("%v conversions must have a single parameter", c.Source)
 		}
-		if err := r.intrinsic(c, r.initializersAndConverters, &r.s.InitializersAndConverters); err != nil {
+		if err := r.intrinsic(c, r.constructorsAndConverters, &r.s.ConstructorsAndConverters); err != nil {
 			return nil, err
 		}
 	}
@@ -360,8 +360,8 @@ func (r *resolver) intrinsic(
 			switch overload.Decl.Kind {
 			case ast.Builtin, ast.Operator:
 				overload.ConstEvalFunction = overload.Decl.Name
-			case ast.Initializer:
-				overload.ConstEvalFunction = "Init"
+			case ast.Constructor:
+				overload.ConstEvalFunction = "Ctor"
 			case ast.Converter:
 				overload.ConstEvalFunction = "Conv"
 			}
@@ -601,7 +601,7 @@ func (r *resolver) calculateUniqueParameterNames() []string {
 		r.s.Builtins,
 		r.s.UnaryOperators,
 		r.s.BinaryOperators,
-		r.s.InitializersAndConverters,
+		r.s.ConstructorsAndConverters,
 	} {
 		for _, i := range intrinsics {
 			for _, o := range i.Overloads {

tools/src/tint/intrinsic/resolver/resolver_test.go

@@ -157,13 +157,13 @@ op +(T<f32>, T<f32>)`,
 		}, {
 			`
 type f32
-init f32(f32)`,
+ctor f32(f32)`,
 			success,
 		}, {
 			`
 type f32
 type T<x>
-init f32(T<f32>)`,
+ctor f32(T<f32>)`,
 			success,
 		}, {
 			`
@@ -392,57 +392,57 @@ op << <M: m>(P<M>)`,
 			`
 type i
 enum e { a }
-init F(i) -> e`,
+ctor F(i) -> e`,
 			`file.txt:3:14 cannot use 'e' as return type. Must be a type or template type`,
 		}, {
 			`
 type T<x>
-init F(T<u>)`,
+ctor F(T<u>)`,
 			`file.txt:2:10 cannot resolve 'u'`,
 		}, {
 			`
 type x
-init F<T>(T<x>)`,
+ctor F<T>(T<x>)`,
 			`file.txt:2:11 'T' template parameters do not accept template arguments`,
 		}, {
 			`
 type A<N: num>
 type B
-init F(A<B>)`,
+ctor F(A<B>)`,
 			`file.txt:3:10 cannot use type 'B' as template number`,
 		}, {
 			`
 type A<N>
 enum E { b }
 match M: E.b
-init F(A<M>)`,
+ctor F(A<M>)`,
 			`file.txt:4:10 cannot use enum matcher 'M' as template type`,
 		}, {
 			`
 type T
 type P<N: num>
 match m: T
-init F(P<m>)`,
+ctor F(P<m>)`,
 			`file.txt:4:10 cannot use type matcher 'm' as template number`,
 		}, {
 			`
 type P<N: num>
 enum E { b }
-init F(P<E>)`,
+ctor F(P<E>)`,
 			`file.txt:3:10 cannot use enum 'E' as template number`,
 		}, {
 			`
 type P<N: num>
 enum E { a b }
 match m: E.a | E.b
-init F(P<m>)`,
+ctor F(P<m>)`,
 			`file.txt:4:10 cannot use enum matcher 'm' as template number`,
 		}, {
 			`
 type P<N: num>
 enum E { a b }
 match m: E.a | E.b
-init F<M: m>(P<M>)`,
+ctor F<M: m>(P<M>)`,
 			`file.txt:4:16 cannot use template enum 'E' as template number`,
 		}, {
 			`

tools/src/tint/intrinsic/sem/sem.go

@@ -31,7 +31,7 @@ type Sem struct {
 	Builtins                  []*Intrinsic
 	UnaryOperators            []*Intrinsic
 	BinaryOperators           []*Intrinsic
-	InitializersAndConverters []*Intrinsic
+	ConstructorsAndConverters []*Intrinsic
 	// Maximum number of template types used across all builtins
 	MaxTemplateTypes int
 	// Maximum number of template numbers used across all builtins

tools/src/tint/intrinsic/tok/tok.go

@@ -31,7 +31,7 @@ const (
 	Match        Kind = "match"
 	Function     Kind = "fn"
 	Operator     Kind = "op"
-	Initializer  Kind = "init"
+	Constructor  Kind = "ctor"
 	Converter    Kind = "conv"
 	Type         Kind = "type"
 	Enum         Kind = "enum"