From 8e20e65dfa7aeca0ae120a3cf95d135cf101cc4d Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 21:08:49 +0100 Subject: [PATCH 1/4] Change generated go code to follow go conventions Normal go conventions encourage the returning on structs rather than pointers or interfaces. It's also normal convension to make optional values pointers, and non-optional concrete types, including stucts, rather than pointers to structs. As it very easy for a someone to choose to take a pointer to a struct in go and pass that around if they want to avoid copies (although the go compiler is heavily optimised to support passing complete structs, even large ones, around), there's little benifit in making embeded structs pointers. It just requires that downstream code needs to be filled with annoying nil checkes, and generally makes it harder to write robust, clean code. Finally rather than having interfaces and "Impl" structs, this change swaps those around. Structs don't have any postfix at all, and interfaces now have an I prefix. The big advantage of this approach is that it makes struct naming much more stable. Previously making a Pkl class open or abstract would result in the generated structs changing their names include "Impl", and the original names becoming interfaces. In turn breaking any code already using the existing structs. Now those breakages won't occur, and devs can opt into using the newly generated interfaces as needed, rather than having to re-write existing code to support the change. --- codegen/src/internal/ClassGen.pkl | 42 +++++++++++++++++++++++------- codegen/src/internal/GoMapping.pkl | 10 +++---- codegen/src/internal/typegen.pkl | 12 ++++----- 3 files changed, 42 insertions(+), 22 deletions(-) diff --git a/codegen/src/internal/ClassGen.pkl b/codegen/src/internal/ClassGen.pkl index 8f5173da..f855ced6 100644 --- a/codegen/src/internal/ClassGen.pkl +++ b/codegen/src/internal/ClassGen.pkl @@ -42,7 +42,7 @@ contents = new Listing { interface when (!isAbstract) { "" - "var _ \(classInfo.interface.name) = (\(classInfo.struct.type.render(classInfo.goPackage)))(nil)" + "var _ \(classInfo.interface.name) = \(classInfo.struct.type.render(classInfo.goPackage)){}" } } when (!isAbstract) { @@ -55,11 +55,11 @@ contents = new Listing { } when (isModule && !isAbstract) { "" - "// LoadFromPath loads the pkl module at the given path and evaluates it into a \(classInfo.name)" - "func LoadFromPath(ctx context.Context, path string) (ret \(classInfo.type.render(classInfo.goPackage)), err error) {" + "// LoadFromPath loads the pkl module at the given path and evaluates it into a \(classInfo.struct.name)" + "func LoadFromPath(ctx context.Context, path string) (ret \(classInfo.struct.type.render(classInfo.goPackage)), err error) {" "\tevaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)" "\tif err != nil {" - "\t\treturn nil, err" + "\t\treturn \(classInfo.struct.type.render(classInfo.goPackage)){}, err" "\t}" "\tdefer func() {" "\t\tcerr := evaluator.Close()" @@ -71,13 +71,13 @@ contents = new Listing { "\treturn ret, err" "}" "" - "// Load loads the pkl module at the given source and evaluates it with the given evaluator into a \(classInfo.name)" - "func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (\(classInfo.type.render(classInfo.goPackage)), error) {" + "// Load loads the pkl module at the given source and evaluates it with the given evaluator into a \(classInfo.struct.name)" + "func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (\(classInfo.struct.type.render(classInfo.goPackage)), error) {" "\tvar ret \(classInfo.struct.name)" "\tif err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {" - "\t\treturn nil, err" + "\t\treturn \(classInfo.struct.name){}, err" "\t}" - "\treturn &ret, nil" + "\treturn ret, nil" "}" } "" @@ -186,7 +186,15 @@ local struct: String = new Listing { when (field.docComment != null) { utils.renderDocComment(field.docComment!!, "\t") } - renderStructField(pklPropertyName, field) + when (field.type == classInfo.type) { + renderStructField(pklPropertyName, (field) { + type = new Type.Pointer { + elem = field.type + } + }) + } else { + renderStructField(pklPropertyName, field) + } } "}" } @@ -200,7 +208,7 @@ local interface: String? = new Listing { "type \(classInfo.interface.name) interface {" when (superClass != null) { - "\t\(superClass.type.render(classInfo.goPackage))" + "\t\(superClass.interface.type.render(classInfo.goPackage))" when (!methodsToGenerate.isEmpty) { "" } @@ -209,6 +217,13 @@ local interface: String? = when (key != methodsToGenerate.keys.first) { "" } + let (field = if (field.type == classInfo.type) + (field) { + type = new Type.Pointer { + elem = field.type + } + } else field + ) "\tGet\(field.name)() \(field.type.render(classInfo.goPackage))" } "}" @@ -259,6 +274,13 @@ local function renderGetter(field: GoStructField): String = new Listing { when (field.docComment != null) { utils.renderDocComment(field.docComment!!, "") } + let (field = if (field.type == classInfo.type) + (field) { + type = new Type.Pointer { + elem = field.type + } + } else field + ) "func (rcv \(classInfo.struct.type.render(classInfo.goPackage))) Get\(field.name)() \(field.type.render(classInfo.goPackage)) {" "\treturn rcv.\(field.name)" "}" diff --git a/codegen/src/internal/GoMapping.pkl b/codegen/src/internal/GoMapping.pkl index 558bd1c8..363d398b 100644 --- a/codegen/src/internal/GoMapping.pkl +++ b/codegen/src/internal/GoMapping.pkl @@ -95,9 +95,9 @@ class Class extends GoMapping { || clazz.superclass.reflectee != Typed && clazz.superclass.reflectee != Module ) new Interface { - name = self.name + name = "I\(self.name)" type = new Type.Declared { - typeName = self.name + typeName = outer.name importPath = self.goPackage package = self.goPackageShort } @@ -107,18 +107,16 @@ class Class extends GoMapping { struct: Struct? = if (clazz.modifiers.contains("abstract")) null else - let (structName = if (interface == null) name else "\(name)Impl") + let (structName = name) new Struct { name = structName clazz = self.clazz - type = new Type.Pointer { - elem = new Type.Declared { + type = new Type.Declared { typeName = structName importPath = self.goPackage package = self.goPackageShort } } - } } diff --git a/codegen/src/internal/typegen.pkl b/codegen/src/internal/typegen.pkl index 8039960d..d28a9577 100644 --- a/codegen/src/internal/typegen.pkl +++ b/codegen/src/internal/typegen.pkl @@ -26,17 +26,17 @@ function generateType( enclosing: reflect.TypeDeclaration, seenMappings: List ): Type = - if (type is reflect.DeclaredType) + if (type is reflect.NullableType) + let (_elem = generateType(type.member, enclosing, seenMappings)) + // No double pointers + if (_elem is Type.Pointer) _elem + else new Type.Pointer { elem = _elem } + else if (type is reflect.DeclaredType) generateDeclaredType(type, enclosing, seenMappings) else if (type is reflect.ModuleType) let (moduleClass = enclosing.enclosingDeclaration.moduleClass) generateType(reflect.DeclaredType(moduleClass), moduleClass, seenMappings) else if (type is reflect.UnionType) generateUnionType(type, seenMappings) - else if (type is reflect.NullableType) - let (_elem = generateType(type.member, enclosing, seenMappings)) - // No double pointers - if (_elem is Type.Pointer) _elem - else new Type.Pointer { elem = _elem } else if (type is reflect.UnknownType) anyType else if (type is reflect.NothingType) throw("Unable to generate Go for the `nothing` type") else if (type is reflect.StringLiteralType) new Type.Declared { typeName = "string" } From d8a7bd9ad5e84c53d2826685bfd9c4fd42c9dcd4 Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 21:09:08 +0100 Subject: [PATCH 2/4] Update codegen snippets with new generated code We've made some big changes in how the codegen works, so we need to update all the snippet outputs to reflect that. --- .../snippet-tests/output/bugholder/A.pkl.go | 2 +- .../snippet-tests/output/bugholder/B.pkl.go | 12 +++++----- .../output/bugholder/Being.pkl.go | 2 +- .../output/bugholder/Bike.pkl.go | 2 +- .../snippet-tests/output/bugholder/Bug.pkl.go | 2 +- .../output/bugholder/BugHolder.pkl.go | 18 +++++++-------- .../snippet-tests/output/bugholder/C.pkl.go | 12 +++++----- .../snippet-tests/output/bugholder/D.pkl.go | 12 +++++----- .../output/bugholder/Person.pkl.go | 22 +++++++++---------- .../output/bugholder/ThisPerson.pkl.go | 22 +++++++++---------- .../output/bugholder/init.pkl.go | 10 ++++----- .../output/cyclicmodule/CyclicModule.pkl.go | 12 +++++----- .../emptyopenmodule/EmptyOpenModule.pkl.go | 14 ++++++------ .../output/emptyopenmodule/init.pkl.go | 2 +- .../explicitname/ExplicitlyCoolName.pkl.go | 12 +++++----- .../output/extendabstractclass/A.pkl.go | 2 +- .../output/extendabstractclass/B.pkl.go | 12 +++++----- .../ExtendsAbstractClass.pkl.go | 12 +++++----- .../output/extendabstractclass/init.pkl.go | 2 +- .../output/extendmodule/ExtendModule.pkl.go | 20 ++++++++--------- .../output/extendmodule/init.pkl.go | 2 +- .../extendopenclass/ExtendingOpenClass.pkl.go | 14 ++++++------ .../output/extendopenclass/MyClass.pkl.go | 12 +++++----- .../output/extendopenclass/MyClass2.pkl.go | 12 +++++----- .../output/extendopenclass/MyOpenClass.pkl.go | 8 +++---- .../output/extendopenclass/init.pkl.go | 6 ++--- .../hiddenproperties/HiddenProperties.pkl.go | 10 ++++----- .../output/moduletype/ModuleType.pkl.go | 12 +++++----- .../moduleusinglib/ModuleUsingLib.pkl.go | 12 +++++----- .../snippet-tests/output/override/Bar.pkl.go | 10 ++++----- .../snippet-tests/output/override/Foo.pkl.go | 2 +- .../output/override/Override.pkl.go | 12 +++++----- .../snippet-tests/output/override/init.pkl.go | 2 +- .../output/override2/MySubclass.pkl.go | 12 +++++----- .../output/override2/Override2.pkl.go | 16 +++++++------- .../output/override2/init.pkl.go | 4 ++-- .../output/structtags/StructTags.pkl.go | 10 ++++----- .../output/support/lib/Lib.pkl.go | 10 ++++----- .../output/support/lib/MyClass.pkl.go | 8 +++---- .../output/support/lib/init.pkl.go | 2 +- .../output/support/lib3/GoGoGo.pkl.go | 8 +++---- .../output/support/lib3/Lib3.pkl.go | 10 ++++----- .../output/support/lib3/init.pkl.go | 2 +- .../output/support/lib4/Lib4.pkl.go | 10 ++++----- .../output/support/lib4/MyLib4.pkl.go | 2 +- .../output/support/openmodule/MyModule.pkl.go | 16 +++++++------- .../output/support/openmodule/init.pkl.go | 2 +- .../snippet-tests/output/union/Union.pkl.go | 10 ++++----- .../unionnamekeyword/UnionNameKeyword.pkl.go | 10 ++++----- 49 files changed, 225 insertions(+), 225 deletions(-) diff --git a/codegen/snippet-tests/output/bugholder/A.pkl.go b/codegen/snippet-tests/output/bugholder/A.pkl.go index 8aea13c7..652efecb 100644 --- a/codegen/snippet-tests/output/bugholder/A.pkl.go +++ b/codegen/snippet-tests/output/bugholder/A.pkl.go @@ -1,6 +1,6 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type A interface { +type IA interface { GetA() string } diff --git a/codegen/snippet-tests/output/bugholder/B.pkl.go b/codegen/snippet-tests/output/bugholder/B.pkl.go index e6638b4d..04e8447c 100644 --- a/codegen/snippet-tests/output/bugholder/B.pkl.go +++ b/codegen/snippet-tests/output/bugholder/B.pkl.go @@ -1,24 +1,24 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type B interface { - A +type IB interface { + IA GetB() string } -var _ B = (*BImpl)(nil) +var _ IB = B{} -type BImpl struct { +type B struct { B string `pkl:"b"` A string `pkl:"a"` } -func (rcv *BImpl) GetB() string { +func (rcv B) GetB() string { return rcv.B } -func (rcv *BImpl) GetA() string { +func (rcv B) GetA() string { return rcv.A } diff --git a/codegen/snippet-tests/output/bugholder/Being.pkl.go b/codegen/snippet-tests/output/bugholder/Being.pkl.go index e852ab89..c7cf290b 100644 --- a/codegen/snippet-tests/output/bugholder/Being.pkl.go +++ b/codegen/snippet-tests/output/bugholder/Being.pkl.go @@ -1,6 +1,6 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type Being interface { +type IBeing interface { GetIsAlive() bool } diff --git a/codegen/snippet-tests/output/bugholder/Bike.pkl.go b/codegen/snippet-tests/output/bugholder/Bike.pkl.go index 676d2139..8a848151 100644 --- a/codegen/snippet-tests/output/bugholder/Bike.pkl.go +++ b/codegen/snippet-tests/output/bugholder/Bike.pkl.go @@ -7,5 +7,5 @@ type Bike struct { // Wheels are the front and back wheels. // // There are typically two of them. - Wheels []*Wheel `pkl:"wheels"` + Wheels []Wheel `pkl:"wheels"` } diff --git a/codegen/snippet-tests/output/bugholder/Bug.pkl.go b/codegen/snippet-tests/output/bugholder/Bug.pkl.go index ef6eae90..299bdd63 100644 --- a/codegen/snippet-tests/output/bugholder/Bug.pkl.go +++ b/codegen/snippet-tests/output/bugholder/Bug.pkl.go @@ -9,7 +9,7 @@ import ( type Bug struct { // The owner of this bug. - Owner *Person `pkl:"owner"` + Owner *IPerson `pkl:"owner"` // The age of this bug Age *int `pkl:"age"` diff --git a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go index c975eb33..1ffb829b 100644 --- a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go +++ b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go @@ -8,20 +8,20 @@ import ( ) type BugHolder struct { - Bug *Bug `pkl:"bug"` + Bug Bug `pkl:"bug"` - N蚊子 *Bug `pkl:"蚊子"` + N蚊子 Bug `pkl:"蚊子"` - ThisPerson ThisPerson `pkl:"thisPerson"` + ThisPerson IThisPerson `pkl:"thisPerson"` - D D `pkl:"d"` + D ID `pkl:"d"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a BugHolder -func LoadFromPath(ctx context.Context, path string) (ret *BugHolder, err error) { +func LoadFromPath(ctx context.Context, path string) (ret BugHolder, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return BugHolder{}, err } defer func() { cerr := evaluator.Close() @@ -34,10 +34,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *BugHolder, err error) } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a BugHolder -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*BugHolder, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (BugHolder, error) { var ret BugHolder if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return BugHolder{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/bugholder/C.pkl.go b/codegen/snippet-tests/output/bugholder/C.pkl.go index d9d39402..0f9a44ec 100644 --- a/codegen/snippet-tests/output/bugholder/C.pkl.go +++ b/codegen/snippet-tests/output/bugholder/C.pkl.go @@ -1,20 +1,20 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type C interface { - B +type IC interface { + IB GetC() string } -var _ C = (*CImpl)(nil) +var _ IC = C{} -type CImpl struct { - *BImpl +type C struct { + B C string `pkl:"c"` } -func (rcv *CImpl) GetC() string { +func (rcv C) GetC() string { return rcv.C } diff --git a/codegen/snippet-tests/output/bugholder/D.pkl.go b/codegen/snippet-tests/output/bugholder/D.pkl.go index 3f570206..3fce452d 100644 --- a/codegen/snippet-tests/output/bugholder/D.pkl.go +++ b/codegen/snippet-tests/output/bugholder/D.pkl.go @@ -1,20 +1,20 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type D interface { - C +type ID interface { + IC GetD() string } -var _ D = (*DImpl)(nil) +var _ ID = D{} -type DImpl struct { - *CImpl +type D struct { + C D string `pkl:"d"` } -func (rcv *DImpl) GetD() string { +func (rcv D) GetD() string { return rcv.D } diff --git a/codegen/snippet-tests/output/bugholder/Person.pkl.go b/codegen/snippet-tests/output/bugholder/Person.pkl.go index b7fe9305..35e5e7b4 100644 --- a/codegen/snippet-tests/output/bugholder/Person.pkl.go +++ b/codegen/snippet-tests/output/bugholder/Person.pkl.go @@ -1,10 +1,10 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type Person interface { - Being +type IPerson interface { + IBeing - GetBike() *Bike + GetBike() Bike GetFirstName() *uint16 @@ -13,13 +13,13 @@ type Person interface { GetThings() map[int]struct{} } -var _ Person = (*PersonImpl)(nil) +var _ IPerson = Person{} // A Person! -type PersonImpl struct { +type Person struct { IsAlive bool `pkl:"isAlive"` - Bike *Bike `pkl:"bike"` + Bike Bike `pkl:"bike"` // The person's first name FirstName *uint16 `pkl:"firstName"` @@ -30,24 +30,24 @@ type PersonImpl struct { Things map[int]struct{} `pkl:"things"` } -func (rcv *PersonImpl) GetIsAlive() bool { +func (rcv Person) GetIsAlive() bool { return rcv.IsAlive } -func (rcv *PersonImpl) GetBike() *Bike { +func (rcv Person) GetBike() Bike { return rcv.Bike } // The person's first name -func (rcv *PersonImpl) GetFirstName() *uint16 { +func (rcv Person) GetFirstName() *uint16 { return rcv.FirstName } // The person's last name -func (rcv *PersonImpl) GetLastName() map[string]*uint32 { +func (rcv Person) GetLastName() map[string]*uint32 { return rcv.LastName } -func (rcv *PersonImpl) GetThings() map[int]struct{} { +func (rcv Person) GetThings() map[int]struct{} { return rcv.Things } diff --git a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go index ff66a6ab..3819b093 100644 --- a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go +++ b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go @@ -1,28 +1,28 @@ // Code generated from Pkl module `org.foo.BugHolder`. DO NOT EDIT. package bugholder -type ThisPerson interface { - Person +type IThisPerson interface { + IPerson - GetMyself() ThisPerson + GetMyself() *IThisPerson - GetSomeoneElse() Person + GetSomeoneElse() IPerson } -var _ ThisPerson = (*ThisPersonImpl)(nil) +var _ IThisPerson = ThisPerson{} -type ThisPersonImpl struct { - *PersonImpl +type ThisPerson struct { + Person - Myself ThisPerson `pkl:"myself"` + Myself *IThisPerson `pkl:"myself"` - SomeoneElse Person `pkl:"someoneElse"` + SomeoneElse IPerson `pkl:"someoneElse"` } -func (rcv *ThisPersonImpl) GetMyself() ThisPerson { +func (rcv ThisPerson) GetMyself() *IThisPerson { return rcv.Myself } -func (rcv *ThisPersonImpl) GetSomeoneElse() Person { +func (rcv ThisPerson) GetSomeoneElse() IPerson { return rcv.SomeoneElse } diff --git a/codegen/snippet-tests/output/bugholder/init.pkl.go b/codegen/snippet-tests/output/bugholder/init.pkl.go index 61949111..10b77f41 100644 --- a/codegen/snippet-tests/output/bugholder/init.pkl.go +++ b/codegen/snippet-tests/output/bugholder/init.pkl.go @@ -6,11 +6,11 @@ import "github.com/apple/pkl-go/pkl" func init() { pkl.RegisterMapping("org.foo.BugHolder", BugHolder{}) pkl.RegisterMapping("org.foo.BugHolder#Bug", Bug{}) - pkl.RegisterMapping("org.foo.BugHolder#Person", PersonImpl{}) + pkl.RegisterMapping("org.foo.BugHolder#Person", Person{}) pkl.RegisterMapping("org.foo.BugHolder#Bike", Bike{}) pkl.RegisterMapping("org.foo.BugHolder#Wheel", Wheel{}) - pkl.RegisterMapping("org.foo.BugHolder#ThisPerson", ThisPersonImpl{}) - pkl.RegisterMapping("org.foo.BugHolder#D", DImpl{}) - pkl.RegisterMapping("org.foo.BugHolder#C", CImpl{}) - pkl.RegisterMapping("org.foo.BugHolder#B", BImpl{}) + pkl.RegisterMapping("org.foo.BugHolder#ThisPerson", ThisPerson{}) + pkl.RegisterMapping("org.foo.BugHolder#D", D{}) + pkl.RegisterMapping("org.foo.BugHolder#C", C{}) + pkl.RegisterMapping("org.foo.BugHolder#B", B{}) } diff --git a/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go b/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go index 0c186c6f..0f4687ec 100644 --- a/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go +++ b/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go @@ -8,14 +8,14 @@ import ( ) type CyclicModule struct { - Thing *Cyclic `pkl:"thing"` + Thing Cyclic `pkl:"thing"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a CyclicModule -func LoadFromPath(ctx context.Context, path string) (ret *CyclicModule, err error) { +func LoadFromPath(ctx context.Context, path string) (ret CyclicModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return CyclicModule{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *CyclicModule, err erro } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a CyclicModule -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*CyclicModule, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (CyclicModule, error) { var ret CyclicModule if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return CyclicModule{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go index ed2c8d17..5609dd0c 100644 --- a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go +++ b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go @@ -7,19 +7,19 @@ import ( "github.com/apple/pkl-go/pkl" ) -type EmptyOpenModule interface { +type IEmptyOpenModule interface { } -var _ EmptyOpenModule = (*EmptyOpenModuleImpl)(nil) +var _ IEmptyOpenModule = EmptyOpenModule{} -type EmptyOpenModuleImpl struct { +type EmptyOpenModule struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a EmptyOpenModule func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return EmptyOpenModule{}, err } defer func() { cerr := evaluator.Close() @@ -33,9 +33,9 @@ func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModule, err er // Load loads the pkl module at the given source and evaluates it with the given evaluator into a EmptyOpenModule func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (EmptyOpenModule, error) { - var ret EmptyOpenModuleImpl + var ret EmptyOpenModule if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return EmptyOpenModule{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go b/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go index e93cc112..97065cbd 100644 --- a/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go +++ b/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go @@ -4,5 +4,5 @@ package emptyopenmodule import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("EmptyOpenModule", EmptyOpenModuleImpl{}) + pkl.RegisterMapping("EmptyOpenModule", EmptyOpenModule{}) } diff --git a/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go b/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go index 414aef24..e11d022a 100644 --- a/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go +++ b/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go @@ -8,14 +8,14 @@ import ( ) type ExplicitlyCoolName struct { - MyCoolProp *SomethingVeryFunny `pkl:"myProp"` + MyCoolProp SomethingVeryFunny `pkl:"myProp"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a ExplicitlyCoolName -func LoadFromPath(ctx context.Context, path string) (ret *ExplicitlyCoolName, err error) { +func LoadFromPath(ctx context.Context, path string) (ret ExplicitlyCoolName, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ExplicitlyCoolName{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *ExplicitlyCoolName, er } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExplicitlyCoolName -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ExplicitlyCoolName, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExplicitlyCoolName, error) { var ret ExplicitlyCoolName if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ExplicitlyCoolName{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/extendabstractclass/A.pkl.go b/codegen/snippet-tests/output/extendabstractclass/A.pkl.go index c4e67fd1..cc5c8342 100644 --- a/codegen/snippet-tests/output/extendabstractclass/A.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/A.pkl.go @@ -1,6 +1,6 @@ // Code generated from Pkl module `ExtendsAbstractClass`. DO NOT EDIT. package extendabstractclass -type A interface { +type IA interface { GetB() string } diff --git a/codegen/snippet-tests/output/extendabstractclass/B.pkl.go b/codegen/snippet-tests/output/extendabstractclass/B.pkl.go index c4eeb11b..4b9704af 100644 --- a/codegen/snippet-tests/output/extendabstractclass/B.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/B.pkl.go @@ -1,24 +1,24 @@ // Code generated from Pkl module `ExtendsAbstractClass`. DO NOT EDIT. package extendabstractclass -type B interface { - A +type IB interface { + IA GetC() string } -var _ B = (*BImpl)(nil) +var _ IB = B{} -type BImpl struct { +type B struct { B string `pkl:"b"` C string `pkl:"c"` } -func (rcv *BImpl) GetB() string { +func (rcv B) GetB() string { return rcv.B } -func (rcv *BImpl) GetC() string { +func (rcv B) GetC() string { return rcv.C } diff --git a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go index 8599679d..fe92fce6 100644 --- a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go @@ -8,14 +8,14 @@ import ( ) type ExtendsAbstractClass struct { - A A `pkl:"a"` + A IA `pkl:"a"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendsAbstractClass -func LoadFromPath(ctx context.Context, path string) (ret *ExtendsAbstractClass, err error) { +func LoadFromPath(ctx context.Context, path string) (ret ExtendsAbstractClass, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ExtendsAbstractClass{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *ExtendsAbstractClass, } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendsAbstractClass -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ExtendsAbstractClass, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendsAbstractClass, error) { var ret ExtendsAbstractClass if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ExtendsAbstractClass{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go index b5dd46db..e9be50b3 100644 --- a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go @@ -5,5 +5,5 @@ import "github.com/apple/pkl-go/pkl" func init() { pkl.RegisterMapping("ExtendsAbstractClass", ExtendsAbstractClass{}) - pkl.RegisterMapping("ExtendsAbstractClass#B", BImpl{}) + pkl.RegisterMapping("ExtendsAbstractClass#B", B{}) } diff --git a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go index 936de627..1a485cde 100644 --- a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go +++ b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go @@ -8,21 +8,21 @@ import ( "github.com/apple/pkl-go/pkl" ) -type ExtendModule interface { - openmodule.MyModule +type IExtendModule interface { + openmodule.IMyModule GetBar() string } -var _ ExtendModule = (*ExtendModuleImpl)(nil) +var _ IExtendModule = ExtendModule{} -type ExtendModuleImpl struct { - *openmodule.MyModuleImpl +type ExtendModule struct { + openmodule.MyModule Bar string `pkl:"bar"` } -func (rcv *ExtendModuleImpl) GetBar() string { +func (rcv ExtendModule) GetBar() string { return rcv.Bar } @@ -30,7 +30,7 @@ func (rcv *ExtendModuleImpl) GetBar() string { func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ExtendModule{}, err } defer func() { cerr := evaluator.Close() @@ -44,9 +44,9 @@ func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendModule func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendModule, error) { - var ret ExtendModuleImpl + var ret ExtendModule if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ExtendModule{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/extendmodule/init.pkl.go b/codegen/snippet-tests/output/extendmodule/init.pkl.go index ec9f22a6..9b3fa5b8 100644 --- a/codegen/snippet-tests/output/extendmodule/init.pkl.go +++ b/codegen/snippet-tests/output/extendmodule/init.pkl.go @@ -4,5 +4,5 @@ package extendmodule import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("ExtendModule", ExtendModuleImpl{}) + pkl.RegisterMapping("ExtendModule", ExtendModule{}) } diff --git a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go index b03cf7bf..c63b8dcd 100644 --- a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go @@ -8,16 +8,16 @@ import ( ) type ExtendingOpenClass struct { - Res1 MyClass `pkl:"res1"` + Res1 IMyClass `pkl:"res1"` - Res2 MyClass2 `pkl:"res2"` + Res2 IMyClass2 `pkl:"res2"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendingOpenClass -func LoadFromPath(ctx context.Context, path string) (ret *ExtendingOpenClass, err error) { +func LoadFromPath(ctx context.Context, path string) (ret ExtendingOpenClass, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ExtendingOpenClass{}, err } defer func() { cerr := evaluator.Close() @@ -30,10 +30,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *ExtendingOpenClass, er } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendingOpenClass -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ExtendingOpenClass, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendingOpenClass, error) { var ret ExtendingOpenClass if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ExtendingOpenClass{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go index ab5a4b11..2d396adc 100644 --- a/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go @@ -1,20 +1,20 @@ // Code generated from Pkl module `ExtendingOpenClass`. DO NOT EDIT. package extendopenclass -type MyClass interface { - MyOpenClass +type IMyClass interface { + IMyOpenClass GetMyBoolean() bool } -var _ MyClass = (*MyClassImpl)(nil) +var _ IMyClass = MyClass{} -type MyClassImpl struct { - *MyOpenClassImpl +type MyClass struct { + MyOpenClass MyBoolean bool `pkl:"myBoolean"` } -func (rcv *MyClassImpl) GetMyBoolean() bool { +func (rcv MyClass) GetMyBoolean() bool { return rcv.MyBoolean } diff --git a/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go b/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go index 75f0f830..23b1eb16 100644 --- a/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go @@ -3,20 +3,20 @@ package extendopenclass import "github.com/apple/pkl-go/codegen/snippet-tests/output/support/lib3" -type MyClass2 interface { - lib3.GoGoGo +type IMyClass2 interface { + lib3.IGoGoGo GetMyBoolean() bool } -var _ MyClass2 = (*MyClass2Impl)(nil) +var _ IMyClass2 = MyClass2{} -type MyClass2Impl struct { - *lib3.GoGoGoImpl +type MyClass2 struct { + lib3.GoGoGo MyBoolean bool `pkl:"myBoolean"` } -func (rcv *MyClass2Impl) GetMyBoolean() bool { +func (rcv MyClass2) GetMyBoolean() bool { return rcv.MyBoolean } diff --git a/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go index aa1f64fc..1c7da196 100644 --- a/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go @@ -1,16 +1,16 @@ // Code generated from Pkl module `ExtendingOpenClass`. DO NOT EDIT. package extendopenclass -type MyOpenClass interface { +type IMyOpenClass interface { GetMyStr() string } -var _ MyOpenClass = (*MyOpenClassImpl)(nil) +var _ IMyOpenClass = MyOpenClass{} -type MyOpenClassImpl struct { +type MyOpenClass struct { MyStr string `pkl:"myStr"` } -func (rcv *MyOpenClassImpl) GetMyStr() string { +func (rcv MyOpenClass) GetMyStr() string { return rcv.MyStr } diff --git a/codegen/snippet-tests/output/extendopenclass/init.pkl.go b/codegen/snippet-tests/output/extendopenclass/init.pkl.go index 9a8e3a6c..5bba1d13 100644 --- a/codegen/snippet-tests/output/extendopenclass/init.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/init.pkl.go @@ -5,7 +5,7 @@ import "github.com/apple/pkl-go/pkl" func init() { pkl.RegisterMapping("ExtendingOpenClass", ExtendingOpenClass{}) - pkl.RegisterMapping("ExtendingOpenClass#MyClass", MyClassImpl{}) - pkl.RegisterMapping("ExtendingOpenClass#MyOpenClass", MyOpenClassImpl{}) - pkl.RegisterMapping("ExtendingOpenClass#MyClass2", MyClass2Impl{}) + pkl.RegisterMapping("ExtendingOpenClass#MyClass", MyClass{}) + pkl.RegisterMapping("ExtendingOpenClass#MyOpenClass", MyOpenClass{}) + pkl.RegisterMapping("ExtendingOpenClass#MyClass2", MyClass2{}) } diff --git a/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go b/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go index 8ae108ba..3d87860b 100644 --- a/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go +++ b/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go @@ -12,10 +12,10 @@ type HiddenProperties struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a HiddenProperties -func LoadFromPath(ctx context.Context, path string) (ret *HiddenProperties, err error) { +func LoadFromPath(ctx context.Context, path string) (ret HiddenProperties, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return HiddenProperties{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *HiddenProperties, err } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a HiddenProperties -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*HiddenProperties, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (HiddenProperties, error) { var ret HiddenProperties if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return HiddenProperties{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go b/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go index 2f60f2bb..cec60397 100644 --- a/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go +++ b/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go @@ -13,16 +13,16 @@ type ModuleType struct { Foo *ModuleType `pkl:"foo"` - Lib *lib4.MyLib4 `pkl:"lib"` + Lib lib4.MyLib4 `pkl:"lib"` FooAgain *ModuleType `pkl:"fooAgain"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a ModuleType -func LoadFromPath(ctx context.Context, path string) (ret *ModuleType, err error) { +func LoadFromPath(ctx context.Context, path string) (ret ModuleType, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ModuleType{}, err } defer func() { cerr := evaluator.Close() @@ -35,10 +35,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *ModuleType, err error) } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ModuleType -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ModuleType, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ModuleType, error) { var ret ModuleType if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ModuleType{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go index e024d9d0..09d05a85 100644 --- a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go +++ b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go @@ -11,7 +11,7 @@ import ( ) type ModuleUsingLib struct { - Res []lib.MyClass `pkl:"res"` + Res []lib.IMyClass `pkl:"res"` Res2 myenum.MyEnum `pkl:"res2"` @@ -21,10 +21,10 @@ type ModuleUsingLib struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a ModuleUsingLib -func LoadFromPath(ctx context.Context, path string) (ret *ModuleUsingLib, err error) { +func LoadFromPath(ctx context.Context, path string) (ret ModuleUsingLib, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ModuleUsingLib{}, err } defer func() { cerr := evaluator.Close() @@ -37,10 +37,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *ModuleUsingLib, err er } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a ModuleUsingLib -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*ModuleUsingLib, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ModuleUsingLib, error) { var ret ModuleUsingLib if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ModuleUsingLib{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/override/Bar.pkl.go b/codegen/snippet-tests/output/override/Bar.pkl.go index 8ae0e66c..15cb1d62 100644 --- a/codegen/snippet-tests/output/override/Bar.pkl.go +++ b/codegen/snippet-tests/output/override/Bar.pkl.go @@ -1,16 +1,16 @@ // Code generated from Pkl module `override`. DO NOT EDIT. package override -type Bar interface { - Foo +type IBar interface { + IFoo } -var _ Bar = (*BarImpl)(nil) +var _ IBar = Bar{} -type BarImpl struct { +type Bar struct { MyProp string `pkl:"myProp"` } -func (rcv *BarImpl) GetMyProp() string { +func (rcv Bar) GetMyProp() string { return rcv.MyProp } diff --git a/codegen/snippet-tests/output/override/Foo.pkl.go b/codegen/snippet-tests/output/override/Foo.pkl.go index 657b5eaa..2f84652d 100644 --- a/codegen/snippet-tests/output/override/Foo.pkl.go +++ b/codegen/snippet-tests/output/override/Foo.pkl.go @@ -1,6 +1,6 @@ // Code generated from Pkl module `override`. DO NOT EDIT. package override -type Foo interface { +type IFoo interface { GetMyProp() string } diff --git a/codegen/snippet-tests/output/override/Override.pkl.go b/codegen/snippet-tests/output/override/Override.pkl.go index b447298c..ad5c7a54 100644 --- a/codegen/snippet-tests/output/override/Override.pkl.go +++ b/codegen/snippet-tests/output/override/Override.pkl.go @@ -8,14 +8,14 @@ import ( ) type Override struct { - Foo Foo `pkl:"foo"` + Foo IFoo `pkl:"foo"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a Override -func LoadFromPath(ctx context.Context, path string) (ret *Override, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Override, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Override{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Override, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Override -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Override, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Override, error) { var ret Override if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Override{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/override/init.pkl.go b/codegen/snippet-tests/output/override/init.pkl.go index f51b9b59..0a7923ca 100644 --- a/codegen/snippet-tests/output/override/init.pkl.go +++ b/codegen/snippet-tests/output/override/init.pkl.go @@ -5,5 +5,5 @@ import "github.com/apple/pkl-go/pkl" func init() { pkl.RegisterMapping("override", Override{}) - pkl.RegisterMapping("override#Bar", BarImpl{}) + pkl.RegisterMapping("override#Bar", Bar{}) } diff --git a/codegen/snippet-tests/output/override2/MySubclass.pkl.go b/codegen/snippet-tests/output/override2/MySubclass.pkl.go index 07248546..188f9323 100644 --- a/codegen/snippet-tests/output/override2/MySubclass.pkl.go +++ b/codegen/snippet-tests/output/override2/MySubclass.pkl.go @@ -1,22 +1,22 @@ // Code generated from Pkl module `Override2`. DO NOT EDIT. package override2 -type MySubclass interface { - Override2 +type IMySubclass interface { + IOverride2 GetFoo() string } -var _ MySubclass = (*MySubclassImpl)(nil) +var _ IMySubclass = MySubclass{} -type MySubclassImpl struct { - *Override2Impl +type MySubclass struct { + Override2 // Different doc comments Foo string `pkl:"foo"` } // Different doc comments -func (rcv *MySubclassImpl) GetFoo() string { +func (rcv MySubclass) GetFoo() string { return rcv.Foo } diff --git a/codegen/snippet-tests/output/override2/Override2.pkl.go b/codegen/snippet-tests/output/override2/Override2.pkl.go index d35fd891..cc3bb3b0 100644 --- a/codegen/snippet-tests/output/override2/Override2.pkl.go +++ b/codegen/snippet-tests/output/override2/Override2.pkl.go @@ -7,19 +7,19 @@ import ( "github.com/apple/pkl-go/pkl" ) -type Override2 interface { +type IOverride2 interface { GetFoo() string } -var _ Override2 = (*Override2Impl)(nil) +var _ IOverride2 = Override2{} -type Override2Impl struct { +type Override2 struct { // Doc comments Foo string `pkl:"foo"` } // Doc comments -func (rcv *Override2Impl) GetFoo() string { +func (rcv Override2) GetFoo() string { return rcv.Foo } @@ -27,7 +27,7 @@ func (rcv *Override2Impl) GetFoo() string { func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Override2{}, err } defer func() { cerr := evaluator.Close() @@ -41,9 +41,9 @@ func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) { // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Override2 func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Override2, error) { - var ret Override2Impl + var ret Override2 if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Override2{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/override2/init.pkl.go b/codegen/snippet-tests/output/override2/init.pkl.go index 921a38ee..f82379b3 100644 --- a/codegen/snippet-tests/output/override2/init.pkl.go +++ b/codegen/snippet-tests/output/override2/init.pkl.go @@ -4,6 +4,6 @@ package override2 import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("Override2", Override2Impl{}) - pkl.RegisterMapping("Override2#MySubclass", MySubclassImpl{}) + pkl.RegisterMapping("Override2", Override2{}) + pkl.RegisterMapping("Override2#MySubclass", MySubclass{}) } diff --git a/codegen/snippet-tests/output/structtags/StructTags.pkl.go b/codegen/snippet-tests/output/structtags/StructTags.pkl.go index d2f10045..653323cb 100644 --- a/codegen/snippet-tests/output/structtags/StructTags.pkl.go +++ b/codegen/snippet-tests/output/structtags/StructTags.pkl.go @@ -32,10 +32,10 @@ type StructTags struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a StructTags -func LoadFromPath(ctx context.Context, path string) (ret *StructTags, err error) { +func LoadFromPath(ctx context.Context, path string) (ret StructTags, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return StructTags{}, err } defer func() { cerr := evaluator.Close() @@ -48,10 +48,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *StructTags, err error) } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a StructTags -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*StructTags, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (StructTags, error) { var ret StructTags if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return StructTags{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/support/lib/Lib.pkl.go b/codegen/snippet-tests/output/support/lib/Lib.pkl.go index 3155a021..94237d77 100644 --- a/codegen/snippet-tests/output/support/lib/Lib.pkl.go +++ b/codegen/snippet-tests/output/support/lib/Lib.pkl.go @@ -11,10 +11,10 @@ type Lib struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Lib -func LoadFromPath(ctx context.Context, path string) (ret *Lib, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Lib, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Lib{}, err } defer func() { cerr := evaluator.Close() @@ -27,10 +27,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Lib, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Lib -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Lib, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Lib, error) { var ret Lib if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Lib{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/support/lib/MyClass.pkl.go b/codegen/snippet-tests/output/support/lib/MyClass.pkl.go index f1fe8c3a..debaaaf4 100644 --- a/codegen/snippet-tests/output/support/lib/MyClass.pkl.go +++ b/codegen/snippet-tests/output/support/lib/MyClass.pkl.go @@ -1,16 +1,16 @@ // Code generated from Pkl module `lib`. DO NOT EDIT. package lib -type MyClass interface { +type IMyClass interface { GetThing() string } -var _ MyClass = (*MyClassImpl)(nil) +var _ IMyClass = MyClass{} -type MyClassImpl struct { +type MyClass struct { Thing string `pkl:"thing"` } -func (rcv *MyClassImpl) GetThing() string { +func (rcv MyClass) GetThing() string { return rcv.Thing } diff --git a/codegen/snippet-tests/output/support/lib/init.pkl.go b/codegen/snippet-tests/output/support/lib/init.pkl.go index 599f09e0..fec07374 100644 --- a/codegen/snippet-tests/output/support/lib/init.pkl.go +++ b/codegen/snippet-tests/output/support/lib/init.pkl.go @@ -4,6 +4,6 @@ package lib import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("lib#MyClass", MyClassImpl{}) + pkl.RegisterMapping("lib#MyClass", MyClass{}) pkl.RegisterMapping("lib", Lib{}) } diff --git a/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go b/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go index d2e18b79..c4a35999 100644 --- a/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go +++ b/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go @@ -1,16 +1,16 @@ // Code generated from Pkl module `lib3`. DO NOT EDIT. package lib3 -type GoGoGo interface { +type IGoGoGo interface { GetDuck() string } -var _ GoGoGo = (*GoGoGoImpl)(nil) +var _ IGoGoGo = GoGoGo{} -type GoGoGoImpl struct { +type GoGoGo struct { Duck string `pkl:"duck"` } -func (rcv *GoGoGoImpl) GetDuck() string { +func (rcv GoGoGo) GetDuck() string { return rcv.Duck } diff --git a/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go b/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go index 4d31e86d..497e3b3c 100644 --- a/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go +++ b/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go @@ -11,10 +11,10 @@ type Lib3 struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Lib3 -func LoadFromPath(ctx context.Context, path string) (ret *Lib3, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Lib3, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Lib3{}, err } defer func() { cerr := evaluator.Close() @@ -27,10 +27,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Lib3, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Lib3 -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Lib3, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Lib3, error) { var ret Lib3 if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Lib3{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/support/lib3/init.pkl.go b/codegen/snippet-tests/output/support/lib3/init.pkl.go index c0a6088a..90a63c70 100644 --- a/codegen/snippet-tests/output/support/lib3/init.pkl.go +++ b/codegen/snippet-tests/output/support/lib3/init.pkl.go @@ -4,6 +4,6 @@ package lib3 import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("lib3#GoGoGo", GoGoGoImpl{}) + pkl.RegisterMapping("lib3#GoGoGo", GoGoGo{}) pkl.RegisterMapping("lib3", Lib3{}) } diff --git a/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go b/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go index 7626de84..c7b2ca91 100644 --- a/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go +++ b/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go @@ -12,10 +12,10 @@ type Lib4 struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Lib4 -func LoadFromPath(ctx context.Context, path string) (ret *Lib4, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Lib4, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Lib4{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Lib4, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Lib4 -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Lib4, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Lib4, error) { var ret Lib4 if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Lib4{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go b/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go index ba1ee231..360454e2 100644 --- a/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go +++ b/codegen/snippet-tests/output/support/lib4/MyLib4.pkl.go @@ -2,5 +2,5 @@ package lib4 type MyLib4 struct { - Foo *Lib4 `pkl:"foo"` + Foo Lib4 `pkl:"foo"` } diff --git a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go index 819cd6f2..323316b7 100644 --- a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go +++ b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go @@ -7,17 +7,17 @@ import ( "github.com/apple/pkl-go/pkl" ) -type MyModule interface { +type IMyModule interface { GetFoo() string } -var _ MyModule = (*MyModuleImpl)(nil) +var _ IMyModule = MyModule{} -type MyModuleImpl struct { +type MyModule struct { Foo string `pkl:"foo"` } -func (rcv *MyModuleImpl) GetFoo() string { +func (rcv MyModule) GetFoo() string { return rcv.Foo } @@ -25,7 +25,7 @@ func (rcv *MyModuleImpl) GetFoo() string { func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return MyModule{}, err } defer func() { cerr := evaluator.Close() @@ -39,9 +39,9 @@ func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) { // Load loads the pkl module at the given source and evaluates it with the given evaluator into a MyModule func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (MyModule, error) { - var ret MyModuleImpl + var ret MyModule if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return MyModule{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/support/openmodule/init.pkl.go b/codegen/snippet-tests/output/support/openmodule/init.pkl.go index a1e95c56..8d1af252 100644 --- a/codegen/snippet-tests/output/support/openmodule/init.pkl.go +++ b/codegen/snippet-tests/output/support/openmodule/init.pkl.go @@ -4,5 +4,5 @@ package openmodule import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("MyModule", MyModuleImpl{}) + pkl.RegisterMapping("MyModule", MyModule{}) } diff --git a/codegen/snippet-tests/output/union/Union.pkl.go b/codegen/snippet-tests/output/union/Union.pkl.go index 6b26ed1a..5f62f3e5 100644 --- a/codegen/snippet-tests/output/union/Union.pkl.go +++ b/codegen/snippet-tests/output/union/Union.pkl.go @@ -26,10 +26,10 @@ type Union struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Union -func LoadFromPath(ctx context.Context, path string) (ret *Union, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Union, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Union{}, err } defer func() { cerr := evaluator.Close() @@ -42,10 +42,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Union, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Union -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Union, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Union, error) { var ret Union if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Union{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go b/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go index d7ee5e9c..d8e6bbda 100644 --- a/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go +++ b/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go @@ -13,10 +13,10 @@ type UnionNameKeyword struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a UnionNameKeyword -func LoadFromPath(ctx context.Context, path string) (ret *UnionNameKeyword, err error) { +func LoadFromPath(ctx context.Context, path string) (ret UnionNameKeyword, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return UnionNameKeyword{}, err } defer func() { cerr := evaluator.Close() @@ -29,10 +29,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *UnionNameKeyword, err } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a UnionNameKeyword -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*UnionNameKeyword, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (UnionNameKeyword, error) { var ret UnionNameKeyword if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return UnionNameKeyword{}, err } - return &ret, nil + return ret, nil } From 66064d3cb1e7af3929ebcdba44893d18cc1966bd Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 20:44:03 +0100 Subject: [PATCH 3/4] Update the test fixtures using the new codegenerator Codegen changes means that the old test fixtures are out of date, and can't be used to test the go binding code. Updating these fixtures breaks the binding code, and identifies the areas that need enhancement. --- pkl/test_fixtures/gen/any/Any.pkl.go | 10 +++++----- pkl/test_fixtures/gen/classes/Animal.pkl.go | 2 +- pkl/test_fixtures/gen/classes/Cat.pkl.go | 12 ++++++------ pkl/test_fixtures/gen/classes/Classes.pkl.go | 16 ++++++++-------- pkl/test_fixtures/gen/classes/Dog.pkl.go | 14 +++++++------- pkl/test_fixtures/gen/classes/Greyhound.pkl.go | 12 ++++++------ pkl/test_fixtures/gen/classes/init.pkl.go | 6 +++--- .../gen/collections/Collections.pkl.go | 10 +++++----- pkl/test_fixtures/gen/datasize/Datasize.pkl.go | 10 +++++----- pkl/test_fixtures/gen/duration/Duration.pkl.go | 10 +++++----- pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go | 10 +++++----- pkl/test_fixtures/gen/nullables/Nullables.pkl.go | 10 +++++----- .../gen/primitives/Primitives.pkl.go | 10 +++++----- pkl/test_fixtures/gen/unions/Unions.pkl.go | 10 +++++----- .../gen/unknown_type/UnknownType.pkl.go | 10 +++++----- 15 files changed, 76 insertions(+), 76 deletions(-) diff --git a/pkl/test_fixtures/gen/any/Any.pkl.go b/pkl/test_fixtures/gen/any/Any.pkl.go index 1bc3b6b6..5bdccec0 100644 --- a/pkl/test_fixtures/gen/any/Any.pkl.go +++ b/pkl/test_fixtures/gen/any/Any.pkl.go @@ -16,10 +16,10 @@ type Any struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Any -func LoadFromPath(ctx context.Context, path string) (ret *Any, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Any, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Any{}, err } defer func() { cerr := evaluator.Close() @@ -32,10 +32,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Any, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Any -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Any, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Any, error) { var ret Any if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Any{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/classes/Animal.pkl.go b/pkl/test_fixtures/gen/classes/Animal.pkl.go index b1857958..140cecc4 100644 --- a/pkl/test_fixtures/gen/classes/Animal.pkl.go +++ b/pkl/test_fixtures/gen/classes/Animal.pkl.go @@ -1,6 +1,6 @@ // Code generated from Pkl module `classes`. DO NOT EDIT. package classes -type Animal interface { +type IAnimal interface { GetName() string } diff --git a/pkl/test_fixtures/gen/classes/Cat.pkl.go b/pkl/test_fixtures/gen/classes/Cat.pkl.go index 84aba1a9..2e97318a 100644 --- a/pkl/test_fixtures/gen/classes/Cat.pkl.go +++ b/pkl/test_fixtures/gen/classes/Cat.pkl.go @@ -1,24 +1,24 @@ // Code generated from Pkl module `classes`. DO NOT EDIT. package classes -type Cat interface { - Animal +type ICat interface { + IAnimal GetMeows() bool } -var _ Cat = (*CatImpl)(nil) +var _ ICat = Cat{} -type CatImpl struct { +type Cat struct { Meows bool `pkl:"meows"` Name string `pkl:"name"` } -func (rcv *CatImpl) GetMeows() bool { +func (rcv Cat) GetMeows() bool { return rcv.Meows } -func (rcv *CatImpl) GetName() string { +func (rcv Cat) GetName() string { return rcv.Name } diff --git a/pkl/test_fixtures/gen/classes/Classes.pkl.go b/pkl/test_fixtures/gen/classes/Classes.pkl.go index 13f50899..3e0fc12d 100644 --- a/pkl/test_fixtures/gen/classes/Classes.pkl.go +++ b/pkl/test_fixtures/gen/classes/Classes.pkl.go @@ -8,18 +8,18 @@ import ( ) type Classes struct { - Animals []Animal `pkl:"animals"` + Animals []IAnimal `pkl:"animals"` - MyAnimal Animal `pkl:"myAnimal"` + MyAnimal IAnimal `pkl:"myAnimal"` - House *House `pkl:"house"` + House House `pkl:"house"` } // LoadFromPath loads the pkl module at the given path and evaluates it into a Classes -func LoadFromPath(ctx context.Context, path string) (ret *Classes, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Classes, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Classes{}, err } defer func() { cerr := evaluator.Close() @@ -32,10 +32,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Classes, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Classes -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Classes, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Classes, error) { var ret Classes if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Classes{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/classes/Dog.pkl.go b/pkl/test_fixtures/gen/classes/Dog.pkl.go index 2f23bbc1..62aee14d 100644 --- a/pkl/test_fixtures/gen/classes/Dog.pkl.go +++ b/pkl/test_fixtures/gen/classes/Dog.pkl.go @@ -1,17 +1,17 @@ // Code generated from Pkl module `classes`. DO NOT EDIT. package classes -type Dog interface { - Animal +type IDog interface { + IAnimal GetBarks() bool GetBreed() string } -var _ Dog = (*DogImpl)(nil) +var _ IDog = Dog{} -type DogImpl struct { +type Dog struct { Barks bool `pkl:"barks"` Breed string `pkl:"breed"` @@ -19,14 +19,14 @@ type DogImpl struct { Name string `pkl:"name"` } -func (rcv *DogImpl) GetBarks() bool { +func (rcv Dog) GetBarks() bool { return rcv.Barks } -func (rcv *DogImpl) GetBreed() string { +func (rcv Dog) GetBreed() string { return rcv.Breed } -func (rcv *DogImpl) GetName() string { +func (rcv Dog) GetName() string { return rcv.Name } diff --git a/pkl/test_fixtures/gen/classes/Greyhound.pkl.go b/pkl/test_fixtures/gen/classes/Greyhound.pkl.go index b8910258..28e66001 100644 --- a/pkl/test_fixtures/gen/classes/Greyhound.pkl.go +++ b/pkl/test_fixtures/gen/classes/Greyhound.pkl.go @@ -1,20 +1,20 @@ // Code generated from Pkl module `classes`. DO NOT EDIT. package classes -type Greyhound interface { - Dog +type IGreyhound interface { + IDog GetCanRoach() bool } -var _ Greyhound = (*GreyhoundImpl)(nil) +var _ IGreyhound = Greyhound{} -type GreyhoundImpl struct { - *DogImpl +type Greyhound struct { + Dog CanRoach bool `pkl:"canRoach"` } -func (rcv *GreyhoundImpl) GetCanRoach() bool { +func (rcv Greyhound) GetCanRoach() bool { return rcv.CanRoach } diff --git a/pkl/test_fixtures/gen/classes/init.pkl.go b/pkl/test_fixtures/gen/classes/init.pkl.go index 6fd024e4..1225d989 100644 --- a/pkl/test_fixtures/gen/classes/init.pkl.go +++ b/pkl/test_fixtures/gen/classes/init.pkl.go @@ -6,7 +6,7 @@ import "github.com/apple/pkl-go/pkl" func init() { pkl.RegisterMapping("classes", Classes{}) pkl.RegisterMapping("classes#House", House{}) - pkl.RegisterMapping("classes#Dog", DogImpl{}) - pkl.RegisterMapping("classes#Greyhound", GreyhoundImpl{}) - pkl.RegisterMapping("classes#Cat", CatImpl{}) + pkl.RegisterMapping("classes#Dog", Dog{}) + pkl.RegisterMapping("classes#Greyhound", Greyhound{}) + pkl.RegisterMapping("classes#Cat", Cat{}) } diff --git a/pkl/test_fixtures/gen/collections/Collections.pkl.go b/pkl/test_fixtures/gen/collections/Collections.pkl.go index 3630fab4..0bd737bb 100644 --- a/pkl/test_fixtures/gen/collections/Collections.pkl.go +++ b/pkl/test_fixtures/gen/collections/Collections.pkl.go @@ -36,10 +36,10 @@ type Collections struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Collections -func LoadFromPath(ctx context.Context, path string) (ret *Collections, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Collections, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Collections{}, err } defer func() { cerr := evaluator.Close() @@ -52,10 +52,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Collections, err error } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Collections -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Collections, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Collections, error) { var ret Collections if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Collections{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/datasize/Datasize.pkl.go b/pkl/test_fixtures/gen/datasize/Datasize.pkl.go index 3d03f0e7..83113990 100644 --- a/pkl/test_fixtures/gen/datasize/Datasize.pkl.go +++ b/pkl/test_fixtures/gen/datasize/Datasize.pkl.go @@ -34,10 +34,10 @@ type Datasize struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Datasize -func LoadFromPath(ctx context.Context, path string) (ret *Datasize, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Datasize, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Datasize{}, err } defer func() { cerr := evaluator.Close() @@ -50,10 +50,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Datasize, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Datasize -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Datasize, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Datasize, error) { var ret Datasize if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Datasize{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/duration/Duration.pkl.go b/pkl/test_fixtures/gen/duration/Duration.pkl.go index e781970f..5b7ad4f2 100644 --- a/pkl/test_fixtures/gen/duration/Duration.pkl.go +++ b/pkl/test_fixtures/gen/duration/Duration.pkl.go @@ -26,10 +26,10 @@ type Duration struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Duration -func LoadFromPath(ctx context.Context, path string) (ret *Duration, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Duration, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Duration{}, err } defer func() { cerr := evaluator.Close() @@ -42,10 +42,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Duration, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Duration -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Duration, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Duration, error) { var ret Duration if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Duration{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go b/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go index d57fd745..4b3a1c2f 100644 --- a/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go +++ b/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go @@ -12,10 +12,10 @@ type Dynamic struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Dynamic -func LoadFromPath(ctx context.Context, path string) (ret *Dynamic, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Dynamic, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Dynamic{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Dynamic, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Dynamic -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Dynamic, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Dynamic, error) { var ret Dynamic if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Dynamic{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/nullables/Nullables.pkl.go b/pkl/test_fixtures/gen/nullables/Nullables.pkl.go index 6908dee3..7ec4cbac 100644 --- a/pkl/test_fixtures/gen/nullables/Nullables.pkl.go +++ b/pkl/test_fixtures/gen/nullables/Nullables.pkl.go @@ -70,10 +70,10 @@ type Nullables struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Nullables -func LoadFromPath(ctx context.Context, path string) (ret *Nullables, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Nullables, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Nullables{}, err } defer func() { cerr := evaluator.Close() @@ -86,10 +86,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Nullables, err error) } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Nullables -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Nullables, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Nullables, error) { var ret Nullables if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Nullables{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/primitives/Primitives.pkl.go b/pkl/test_fixtures/gen/primitives/Primitives.pkl.go index 6083eb45..e28428cd 100644 --- a/pkl/test_fixtures/gen/primitives/Primitives.pkl.go +++ b/pkl/test_fixtures/gen/primitives/Primitives.pkl.go @@ -38,10 +38,10 @@ type Primitives struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Primitives -func LoadFromPath(ctx context.Context, path string) (ret *Primitives, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Primitives, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Primitives{}, err } defer func() { cerr := evaluator.Close() @@ -54,10 +54,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Primitives, err error) } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Primitives -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Primitives, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Primitives, error) { var ret Primitives if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Primitives{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/unions/Unions.pkl.go b/pkl/test_fixtures/gen/unions/Unions.pkl.go index 43898a99..2c0d0991 100644 --- a/pkl/test_fixtures/gen/unions/Unions.pkl.go +++ b/pkl/test_fixtures/gen/unions/Unions.pkl.go @@ -16,10 +16,10 @@ type Unions struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a Unions -func LoadFromPath(ctx context.Context, path string) (ret *Unions, err error) { +func LoadFromPath(ctx context.Context, path string) (ret Unions, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Unions{}, err } defer func() { cerr := evaluator.Close() @@ -32,10 +32,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *Unions, err error) { } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a Unions -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Unions, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Unions, error) { var ret Unions if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Unions{}, err } - return &ret, nil + return ret, nil } diff --git a/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go b/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go index 414a9973..f78c52cc 100644 --- a/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go +++ b/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go @@ -12,10 +12,10 @@ type UnknownType struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a UnknownType -func LoadFromPath(ctx context.Context, path string) (ret *UnknownType, err error) { +func LoadFromPath(ctx context.Context, path string) (ret UnknownType, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return UnknownType{}, err } defer func() { cerr := evaluator.Close() @@ -28,10 +28,10 @@ func LoadFromPath(ctx context.Context, path string) (ret *UnknownType, err error } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a UnknownType -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*UnknownType, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (UnknownType, error) { var ret UnknownType if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return UnknownType{}, err } - return &ret, nil + return ret, nil } From 603e96ed01e438799693b99783fb1925205320d7 Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 20:45:11 +0100 Subject: [PATCH 4/4] Add support for decoding into concreet structs The codegen changes means we need to support decoding data into concreet structs, and not just pointers to structs. --- pkl/decode_struct.go | 32 ++++++++++++++++++++++++-------- pkl/unmarshal_test.go | 14 +++++++------- 2 files changed, 31 insertions(+), 15 deletions(-) diff --git a/pkl/decode_struct.go b/pkl/decode_struct.go index 77dc4ed7..506b3bb4 100644 --- a/pkl/decode_struct.go +++ b/pkl/decode_struct.go @@ -306,8 +306,15 @@ func getStructFields(typ reflect.Type) map[string]structField { field := typ.Field(i) // embedded if field.Anonymous { - for k, v := range getStructFields(field.Type.Elem()) { - ret[k] = v + switch field.Type.Kind() { + case reflect.Ptr: + for k, v := range getStructFields(field.Type.Elem()) { + ret[k] = v + } + case reflect.Struct: + for k, v := range getStructFields(field.Type) { + ret[k] = v + } } } else { opts := parseStructOpts(&field) @@ -328,13 +335,22 @@ func (d *decoder) getOutputValue(typ reflect.Type) (*reflect.Value, error) { for i := 0; i < numFields; i++ { field := typ.Field(i) if field.Anonymous { - fieldValue := reflect.New(field.Type.Elem()) - // Assertion: all embedded fields are pointers to structs. - structValue, err := d.getOutputValue(field.Type.Elem()) - if err != nil { - return nil, err + var fieldValue reflect.Value + switch field.Type.Kind() { + case reflect.Ptr: + { + fieldValue = reflect.New(field.Type.Elem()) + structValue, err := d.getOutputValue(field.Type.Elem()) + if err != nil { + return nil, err + } + fieldValue.Elem().Set(*structValue) + } + case reflect.Struct: + { + fieldValue = reflect.New(field.Type).Elem() + } } - fieldValue.Elem().Set(*structValue) ret.FieldByName(field.Name).Set(fieldValue) } } diff --git a/pkl/unmarshal_test.go b/pkl/unmarshal_test.go index 0885c142..132c81c9 100644 --- a/pkl/unmarshal_test.go +++ b/pkl/unmarshal_test.go @@ -310,29 +310,29 @@ func TestUnmarshal_Dynamic(t *testing.T) { func TestUnmarshal_Classes(t *testing.T) { expected := classes.Classes{ - Animals: []classes.Animal{ - &classes.GreyhoundImpl{ - DogImpl: &classes.DogImpl{ + Animals: []classes.IAnimal{ + &classes.Greyhound{ + Dog: classes.Dog{ Name: "Uni", Barks: false, Breed: "Greyhound", }, CanRoach: true, }, - &classes.CatImpl{ + &classes.Cat{ Name: "Millie", Meows: true, }, }, - MyAnimal: &classes.GreyhoundImpl{ - DogImpl: &classes.DogImpl{ + MyAnimal: &classes.Greyhound{ + Dog: classes.Dog{ Name: "Uni", Barks: false, Breed: "Greyhound", }, CanRoach: true, }, - House: &classes.House{ + House: classes.House{ Area: 2000, Bedrooms: 3, Bathrooms: 2,