diff --git a/codegen/snippet-tests/output/bugholder/A.pkl.go b/codegen/snippet-tests/output/bugholder/A.pkl.go index 8aea13c..652efec 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 e6638b4..04e8447 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 e852ab8..c7cf290 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 676d213..8a84815 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 ef6eae9..299bdd6 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 c975eb3..1ffb829 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 d9d3940..0f9a44e 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 3f57020..3fce452 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 b7fe930..35e5e7b 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 ff66a6a..3819b09 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 6194911..10b77f4 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 0c186c6..0f4687e 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 ed2c8d1..5609dd0 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 e93cc11..97065cb 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 414aef2..e11d022 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 c4e67fd..cc5c834 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 c4eeb11..4b9704a 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 8599679..fe92fce 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 b5dd46d..e9be50b 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 936de62..1a485cd 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 ec9f22a..9b3fa5b 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 b03cf7b..c63b8dc 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 ab5a4b1..2d396ad 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 75f0f83..23b1eb1 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 aa1f64f..1c7da19 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 9a8e3a6..5bba1d1 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 8ae108b..3d87860 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 2f60f2b..cec6039 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 e024d9d..09d05a8 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 8ae0e66..15cb1d6 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 657b5ea..2f84652 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 b447298..ad5c7a5 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 f51b9b5..0a7923c 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 0724854..188f932 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 d35fd89..cc3bb3b 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 921a38e..f82379b 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 d2f1004..653323c 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 3155a02..94237d7 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 f1fe8c3..debaaaf 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 599f09e..fec0737 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 d2e18b7..c4a3599 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 4d31e86..497e3b3 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 c0a6088..90a63c7 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 7626de8..c7b2ca9 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 ba1ee23..360454e 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 819cd6f..323316b 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 a1e95c5..8d1af25 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 6b26ed1..5f62f3e 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 d7ee5e9..d8e6bbd 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 } diff --git a/codegen/src/internal/ClassGen.pkl b/codegen/src/internal/ClassGen.pkl index 8f5173d..f855ced 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 558bd1c..363d398 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 8039960..d28a957 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" } diff --git a/pkl/decode_struct.go b/pkl/decode_struct.go index 77dc4ed..506b3bb 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/test_fixtures/gen/any/Any.pkl.go b/pkl/test_fixtures/gen/any/Any.pkl.go index 1bc3b6b..5bdccec 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 b185795..140cecc 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 84aba1a..2e97318 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 13f5089..3e0fc12 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 2f23bbc..62aee14 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 b891025..28e6600 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 6fd024e..1225d98 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 3630fab..0bd737b 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 3d03f0e..8311399 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 e781970..5b7ad4f 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 d57fd74..4b3a1c2 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 6908dee..7ec4cba 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 6083eb4..e28428c 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 43898a9..2c0d099 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 414a997..f78c52c 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 } diff --git a/pkl/unmarshal_test.go b/pkl/unmarshal_test.go index 0885c14..132c81c 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,