From 51d3840551668f185ac8e4fc9196ca19d2e65278 Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 21:08:49 +0100 Subject: [PATCH 1/7] 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. --- .../snippet-tests/output/bugholder/B.pkl.go | 6 +-- .../output/bugholder/Bike.pkl.go | 2 +- .../output/bugholder/BugHolder.pkl.go | 14 +++---- .../snippet-tests/output/bugholder/C.pkl.go | 6 +-- .../snippet-tests/output/bugholder/D.pkl.go | 6 +-- .../output/bugholder/Person.pkl.go | 16 +++---- .../output/bugholder/ThisPerson.pkl.go | 12 +++--- .../output/cyclicmodule/CyclicModule.pkl.go | 12 +++--- .../emptyopenmodule/EmptyOpenModule.pkl.go | 16 +++---- .../explicitname/ExplicitlyCoolName.pkl.go | 12 +++--- .../ExtendsAbstractClass.pkl.go | 10 ++--- .../output/extendmodule/ExtendModule.pkl.go | 20 ++++----- .../extendopenclass/ExtendingOpenClass.pkl.go | 10 ++--- .../output/extendopenclass/MyClass.pkl.go | 6 +-- .../output/extendopenclass/MyClass2.pkl.go | 6 +-- .../output/extendopenclass/MyOpenClass.pkl.go | 4 +- .../hiddenproperties/HiddenProperties.pkl.go | 10 ++--- .../output/moduletype/ModuleType.pkl.go | 12 +++--- .../moduleusinglib/ModuleUsingLib.pkl.go | 10 ++--- .../snippet-tests/output/override/Bar.pkl.go | 4 +- .../output/override/Override.pkl.go | 10 ++--- .../output/override2/MySubclass.pkl.go | 6 +-- .../output/override2/Override2.pkl.go | 18 ++++---- .../output/structtags/StructTags.pkl.go | 10 ++--- .../output/support/lib/Lib.pkl.go | 10 ++--- .../output/support/lib/MyClass.pkl.go | 4 +- .../output/support/lib3/GoGoGo.pkl.go | 4 +- .../output/support/lib3/Lib3.pkl.go | 10 ++--- .../output/support/lib4/Lib4.pkl.go | 10 ++--- .../output/support/lib4/MyLib4.pkl.go | 2 +- .../output/support/openmodule/MyModule.pkl.go | 18 ++++---- .../snippet-tests/output/union/Union.pkl.go | 10 ++--- .../unionnamekeyword/UnionNameKeyword.pkl.go | 10 ++--- codegen/src/internal/ClassGen.pkl | 42 ++++++++++++++----- codegen/src/internal/GoMapping.pkl | 10 ++--- codegen/src/internal/typegen.pkl | 12 +++--- 36 files changed, 200 insertions(+), 180 deletions(-) diff --git a/codegen/snippet-tests/output/bugholder/B.pkl.go b/codegen/snippet-tests/output/bugholder/B.pkl.go index e6638b4..bb1f4b2 100644 --- a/codegen/snippet-tests/output/bugholder/B.pkl.go +++ b/codegen/snippet-tests/output/bugholder/B.pkl.go @@ -7,7 +7,7 @@ type B interface { GetB() string } -var _ B = (*BImpl)(nil) +var _ B = BImpl{} type BImpl struct { B string `pkl:"b"` @@ -15,10 +15,10 @@ type BImpl struct { A string `pkl:"a"` } -func (rcv *BImpl) GetB() string { +func (rcv BImpl) GetB() string { return rcv.B } -func (rcv *BImpl) GetA() string { +func (rcv BImpl) GetA() string { return rcv.A } 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/BugHolder.pkl.go b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go index c975eb3..0f7fb31 100644 --- a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go +++ b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go @@ -8,9 +8,9 @@ import ( ) type BugHolder struct { - Bug *Bug `pkl:"bug"` + Bug Bug `pkl:"bug"` - N蚊子 *Bug `pkl:"蚊子"` + N蚊子 Bug `pkl:"蚊子"` ThisPerson ThisPerson `pkl:"thisPerson"` @@ -18,10 +18,10 @@ type BugHolder struct { } // 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..eaa2e8a 100644 --- a/codegen/snippet-tests/output/bugholder/C.pkl.go +++ b/codegen/snippet-tests/output/bugholder/C.pkl.go @@ -7,14 +7,14 @@ type C interface { GetC() string } -var _ C = (*CImpl)(nil) +var _ C = CImpl{} type CImpl struct { - *BImpl + BImpl C string `pkl:"c"` } -func (rcv *CImpl) GetC() string { +func (rcv CImpl) 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..d4becf6 100644 --- a/codegen/snippet-tests/output/bugholder/D.pkl.go +++ b/codegen/snippet-tests/output/bugholder/D.pkl.go @@ -7,14 +7,14 @@ type D interface { GetD() string } -var _ D = (*DImpl)(nil) +var _ D = DImpl{} type DImpl struct { - *CImpl + CImpl D string `pkl:"d"` } -func (rcv *DImpl) GetD() string { +func (rcv DImpl) 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..e1b2993 100644 --- a/codegen/snippet-tests/output/bugholder/Person.pkl.go +++ b/codegen/snippet-tests/output/bugholder/Person.pkl.go @@ -4,7 +4,7 @@ package bugholder type Person interface { Being - GetBike() *Bike + GetBike() Bike GetFirstName() *uint16 @@ -13,13 +13,13 @@ type Person interface { GetThings() map[int]struct{} } -var _ Person = (*PersonImpl)(nil) +var _ Person = PersonImpl{} // A Person! type PersonImpl 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 PersonImpl) GetIsAlive() bool { return rcv.IsAlive } -func (rcv *PersonImpl) GetBike() *Bike { +func (rcv PersonImpl) GetBike() Bike { return rcv.Bike } // The person's first name -func (rcv *PersonImpl) GetFirstName() *uint16 { +func (rcv PersonImpl) GetFirstName() *uint16 { return rcv.FirstName } // The person's last name -func (rcv *PersonImpl) GetLastName() map[string]*uint32 { +func (rcv PersonImpl) GetLastName() map[string]*uint32 { return rcv.LastName } -func (rcv *PersonImpl) GetThings() map[int]struct{} { +func (rcv PersonImpl) 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..39f931c 100644 --- a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go +++ b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go @@ -4,25 +4,25 @@ package bugholder type ThisPerson interface { Person - GetMyself() ThisPerson + GetMyself() *ThisPerson GetSomeoneElse() Person } -var _ ThisPerson = (*ThisPersonImpl)(nil) +var _ ThisPerson = ThisPersonImpl{} type ThisPersonImpl struct { - *PersonImpl + PersonImpl - Myself ThisPerson `pkl:"myself"` + Myself *ThisPerson `pkl:"myself"` SomeoneElse Person `pkl:"someoneElse"` } -func (rcv *ThisPersonImpl) GetMyself() ThisPerson { +func (rcv ThisPersonImpl) GetMyself() *ThisPerson { return rcv.Myself } -func (rcv *ThisPersonImpl) GetSomeoneElse() Person { +func (rcv ThisPersonImpl) GetSomeoneElse() Person { return rcv.SomeoneElse } 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..45acde4 100644 --- a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go +++ b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go @@ -10,16 +10,16 @@ import ( type EmptyOpenModule interface { } -var _ EmptyOpenModule = (*EmptyOpenModuleImpl)(nil) +var _ EmptyOpenModule = EmptyOpenModuleImpl{} type EmptyOpenModuleImpl 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) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a EmptyOpenModuleImpl +func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModuleImpl, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return EmptyOpenModuleImpl{}, err } defer func() { cerr := evaluator.Close() @@ -31,11 +31,11 @@ func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModule, err er return ret, err } -// 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) { +// Load loads the pkl module at the given source and evaluates it with the given evaluator into a EmptyOpenModuleImpl +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (EmptyOpenModuleImpl, error) { var ret EmptyOpenModuleImpl if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return EmptyOpenModuleImpl{}, err } - return &ret, nil + return ret, nil } 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/ExtendsAbstractClass.pkl.go b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go index 8599679..d2b82de 100644 --- a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go @@ -12,10 +12,10 @@ type ExtendsAbstractClass struct { } // 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/extendmodule/ExtendModule.pkl.go b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go index 936de62..4408520 100644 --- a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go +++ b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go @@ -14,23 +14,23 @@ type ExtendModule interface { GetBar() string } -var _ ExtendModule = (*ExtendModuleImpl)(nil) +var _ ExtendModule = ExtendModuleImpl{} type ExtendModuleImpl struct { - *openmodule.MyModuleImpl + openmodule.MyModuleImpl Bar string `pkl:"bar"` } -func (rcv *ExtendModuleImpl) GetBar() string { +func (rcv ExtendModuleImpl) GetBar() string { return rcv.Bar } -// LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendModule -func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendModuleImpl +func LoadFromPath(ctx context.Context, path string) (ret ExtendModuleImpl, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return ExtendModuleImpl{}, err } defer func() { cerr := evaluator.Close() @@ -42,11 +42,11 @@ func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error return ret, err } -// 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) { +// Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendModuleImpl +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendModuleImpl, error) { var ret ExtendModuleImpl if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return ExtendModuleImpl{}, err } - return &ret, nil + return ret, nil } diff --git a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go index b03cf7b..29b5ed7 100644 --- a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go @@ -14,10 +14,10 @@ type ExtendingOpenClass struct { } // 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..d542203 100644 --- a/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/MyClass.pkl.go @@ -7,14 +7,14 @@ type MyClass interface { GetMyBoolean() bool } -var _ MyClass = (*MyClassImpl)(nil) +var _ MyClass = MyClassImpl{} type MyClassImpl struct { - *MyOpenClassImpl + MyOpenClassImpl MyBoolean bool `pkl:"myBoolean"` } -func (rcv *MyClassImpl) GetMyBoolean() bool { +func (rcv MyClassImpl) 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..c534e84 100644 --- a/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/MyClass2.pkl.go @@ -9,14 +9,14 @@ type MyClass2 interface { GetMyBoolean() bool } -var _ MyClass2 = (*MyClass2Impl)(nil) +var _ MyClass2 = MyClass2Impl{} type MyClass2Impl struct { - *lib3.GoGoGoImpl + lib3.GoGoGoImpl MyBoolean bool `pkl:"myBoolean"` } -func (rcv *MyClass2Impl) GetMyBoolean() bool { +func (rcv MyClass2Impl) 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..e7e1d30 100644 --- a/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/MyOpenClass.pkl.go @@ -5,12 +5,12 @@ type MyOpenClass interface { GetMyStr() string } -var _ MyOpenClass = (*MyOpenClassImpl)(nil) +var _ MyOpenClass = MyOpenClassImpl{} type MyOpenClassImpl struct { MyStr string `pkl:"myStr"` } -func (rcv *MyOpenClassImpl) GetMyStr() string { +func (rcv MyOpenClassImpl) GetMyStr() string { return rcv.MyStr } 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..ee48135 100644 --- a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go +++ b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go @@ -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..d54ad85 100644 --- a/codegen/snippet-tests/output/override/Bar.pkl.go +++ b/codegen/snippet-tests/output/override/Bar.pkl.go @@ -5,12 +5,12 @@ type Bar interface { Foo } -var _ Bar = (*BarImpl)(nil) +var _ Bar = BarImpl{} type BarImpl struct { MyProp string `pkl:"myProp"` } -func (rcv *BarImpl) GetMyProp() string { +func (rcv BarImpl) GetMyProp() string { return rcv.MyProp } diff --git a/codegen/snippet-tests/output/override/Override.pkl.go b/codegen/snippet-tests/output/override/Override.pkl.go index b447298..eb7d60e 100644 --- a/codegen/snippet-tests/output/override/Override.pkl.go +++ b/codegen/snippet-tests/output/override/Override.pkl.go @@ -12,10 +12,10 @@ type Override struct { } // 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/override2/MySubclass.pkl.go b/codegen/snippet-tests/output/override2/MySubclass.pkl.go index 0724854..1775168 100644 --- a/codegen/snippet-tests/output/override2/MySubclass.pkl.go +++ b/codegen/snippet-tests/output/override2/MySubclass.pkl.go @@ -7,16 +7,16 @@ type MySubclass interface { GetFoo() string } -var _ MySubclass = (*MySubclassImpl)(nil) +var _ MySubclass = MySubclassImpl{} type MySubclassImpl struct { - *Override2Impl + Override2Impl // Different doc comments Foo string `pkl:"foo"` } // Different doc comments -func (rcv *MySubclassImpl) GetFoo() string { +func (rcv MySubclassImpl) 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..e24487c 100644 --- a/codegen/snippet-tests/output/override2/Override2.pkl.go +++ b/codegen/snippet-tests/output/override2/Override2.pkl.go @@ -11,7 +11,7 @@ type Override2 interface { GetFoo() string } -var _ Override2 = (*Override2Impl)(nil) +var _ Override2 = Override2Impl{} type Override2Impl struct { // Doc comments @@ -19,15 +19,15 @@ type Override2Impl struct { } // Doc comments -func (rcv *Override2Impl) GetFoo() string { +func (rcv Override2Impl) GetFoo() string { return rcv.Foo } -// LoadFromPath loads the pkl module at the given path and evaluates it into a Override2 -func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a Override2Impl +func LoadFromPath(ctx context.Context, path string) (ret Override2Impl, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return Override2Impl{}, err } defer func() { cerr := evaluator.Close() @@ -39,11 +39,11 @@ func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) { return ret, err } -// 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) { +// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Override2Impl +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Override2Impl, error) { var ret Override2Impl if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return Override2Impl{}, err } - return &ret, nil + return ret, nil } 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..3da26e1 100644 --- a/codegen/snippet-tests/output/support/lib/MyClass.pkl.go +++ b/codegen/snippet-tests/output/support/lib/MyClass.pkl.go @@ -5,12 +5,12 @@ type MyClass interface { GetThing() string } -var _ MyClass = (*MyClassImpl)(nil) +var _ MyClass = MyClassImpl{} type MyClassImpl struct { Thing string `pkl:"thing"` } -func (rcv *MyClassImpl) GetThing() string { +func (rcv MyClassImpl) GetThing() string { return rcv.Thing } diff --git a/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go b/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go index d2e18b7..20c27b5 100644 --- a/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go +++ b/codegen/snippet-tests/output/support/lib3/GoGoGo.pkl.go @@ -5,12 +5,12 @@ type GoGoGo interface { GetDuck() string } -var _ GoGoGo = (*GoGoGoImpl)(nil) +var _ GoGoGo = GoGoGoImpl{} type GoGoGoImpl struct { Duck string `pkl:"duck"` } -func (rcv *GoGoGoImpl) GetDuck() string { +func (rcv GoGoGoImpl) 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/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..ab9d362 100644 --- a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go +++ b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go @@ -11,21 +11,21 @@ type MyModule interface { GetFoo() string } -var _ MyModule = (*MyModuleImpl)(nil) +var _ MyModule = MyModuleImpl{} type MyModuleImpl struct { Foo string `pkl:"foo"` } -func (rcv *MyModuleImpl) GetFoo() string { +func (rcv MyModuleImpl) GetFoo() string { return rcv.Foo } -// LoadFromPath loads the pkl module at the given path and evaluates it into a MyModule -func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a MyModuleImpl +func LoadFromPath(ctx context.Context, path string) (ret MyModuleImpl, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return MyModuleImpl{}, err } defer func() { cerr := evaluator.Close() @@ -37,11 +37,11 @@ func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) { return ret, err } -// 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) { +// Load loads the pkl module at the given source and evaluates it with the given evaluator into a MyModuleImpl +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (MyModuleImpl, error) { var ret MyModuleImpl if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err + return MyModuleImpl{}, err } - return &ret, nil + return ret, nil } 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 14b1159..1482cf8 100644 --- a/codegen/src/internal/ClassGen.pkl +++ b/codegen/src/internal/ClassGen.pkl @@ -43,7 +43,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) { @@ -56,11 +56,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()" @@ -72,13 +72,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" "}" } "" @@ -187,7 +187,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) + } } "}" } @@ -201,7 +209,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) { "" } @@ -210,6 +218,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))" } "}" @@ -260,6 +275,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 2a68557..999bd52 100644 --- a/codegen/src/internal/GoMapping.pkl +++ b/codegen/src/internal/GoMapping.pkl @@ -96,9 +96,9 @@ class Class extends GoMapping { || clazz.superclass.reflectee != Typed && clazz.superclass.reflectee != Module ) new Interface { - name = self.name + name = "\(self.name)" type = new Type.Declared { - typeName = self.name + typeName = outer.name importPath = self.goPackage package = self.goPackageShort } @@ -108,18 +108,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 = if (self.interface == null) name else "\(self.name)Impl") 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 63f9f65..e467941 100644 --- a/codegen/src/internal/typegen.pkl +++ b/codegen/src/internal/typegen.pkl @@ -27,17 +27,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 6e8950e5c7a99193877e8f9e03f9cbebc3b1bf11 Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 20:44:03 +0100 Subject: [PATCH 2/7] 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/Cat.pkl.go | 6 +++--- pkl/test_fixtures/gen/classes/Classes.pkl.go | 12 ++++++------ pkl/test_fixtures/gen/classes/Dog.pkl.go | 8 ++++---- pkl/test_fixtures/gen/classes/Greyhound.pkl.go | 6 +++--- pkl/test_fixtures/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 +++++----- pkl/test_fixtures/gen/primitives/Primitives.pkl.go | 10 +++++----- pkl/test_fixtures/gen/unions/Unions.pkl.go | 10 +++++----- .../gen/unknown_type/UnknownType.pkl.go | 10 +++++----- 13 files changed, 61 insertions(+), 61 deletions(-) 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/Cat.pkl.go b/pkl/test_fixtures/gen/classes/Cat.pkl.go index 84aba1a..40534d6 100644 --- a/pkl/test_fixtures/gen/classes/Cat.pkl.go +++ b/pkl/test_fixtures/gen/classes/Cat.pkl.go @@ -7,7 +7,7 @@ type Cat interface { GetMeows() bool } -var _ Cat = (*CatImpl)(nil) +var _ Cat = CatImpl{} type CatImpl struct { Meows bool `pkl:"meows"` @@ -15,10 +15,10 @@ type CatImpl struct { Name string `pkl:"name"` } -func (rcv *CatImpl) GetMeows() bool { +func (rcv CatImpl) GetMeows() bool { return rcv.Meows } -func (rcv *CatImpl) GetName() string { +func (rcv CatImpl) 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..dd77b5c 100644 --- a/pkl/test_fixtures/gen/classes/Classes.pkl.go +++ b/pkl/test_fixtures/gen/classes/Classes.pkl.go @@ -12,14 +12,14 @@ type Classes struct { MyAnimal Animal `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..ccff6b2 100644 --- a/pkl/test_fixtures/gen/classes/Dog.pkl.go +++ b/pkl/test_fixtures/gen/classes/Dog.pkl.go @@ -9,7 +9,7 @@ type Dog interface { GetBreed() string } -var _ Dog = (*DogImpl)(nil) +var _ Dog = DogImpl{} type DogImpl struct { Barks bool `pkl:"barks"` @@ -19,14 +19,14 @@ type DogImpl struct { Name string `pkl:"name"` } -func (rcv *DogImpl) GetBarks() bool { +func (rcv DogImpl) GetBarks() bool { return rcv.Barks } -func (rcv *DogImpl) GetBreed() string { +func (rcv DogImpl) GetBreed() string { return rcv.Breed } -func (rcv *DogImpl) GetName() string { +func (rcv DogImpl) 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..8102426 100644 --- a/pkl/test_fixtures/gen/classes/Greyhound.pkl.go +++ b/pkl/test_fixtures/gen/classes/Greyhound.pkl.go @@ -7,14 +7,14 @@ type Greyhound interface { GetCanRoach() bool } -var _ Greyhound = (*GreyhoundImpl)(nil) +var _ Greyhound = GreyhoundImpl{} type GreyhoundImpl struct { - *DogImpl + DogImpl CanRoach bool `pkl:"canRoach"` } -func (rcv *GreyhoundImpl) GetCanRoach() bool { +func (rcv GreyhoundImpl) GetCanRoach() bool { return rcv.CanRoach } 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 } From 8d7b829ef63800c7445e4fdb322ff3fb5fa30506 Mon Sep 17 00:00:00 2001 From: Thomas Purchas Date: Sun, 30 Jun 2024 20:45:11 +0100 Subject: [PATCH 3/7] Add support for decoding into concrete structs The codegen changes means we need to support decoding data into concrete 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 5a570cc..ad4160d 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 fd8cf24..1826dea 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, From a42fedeaf54d39312789938064b5374d57c4b26f Mon Sep 17 00:00:00 2001 From: Dan Chao Date: Mon, 21 Apr 2025 20:56:05 -0700 Subject: [PATCH 4/7] Fix concrete structs * Revert rename-based changes (no I-prefix for interfaces, structs have Impl postfix) * Change built-in types to be non-pointer types too (pkl.Duration vs *pkl.Duration) * Detect whether `RegisterMapping` receives a pointer vs non-pointer (this is a breaking change) * Change `GeneratorSettings.pkl.go` to use non-pointer types --- .gitignore | 1 + cmd/internal/gen-snippets/gen-snippets.go | 8 +- .../GeneratorSettings.pkl.go | 17 ++-- cmd/pkl-gen-go/pkg/generate.go | 8 +- cmd/pkl-gen-go/pkl-gen-go.go | 6 +- codegen/snippet-tests/input/CyclicModule.pkl | 2 +- codegen/snippet-tests/input/ModuleType.pkl | 4 +- .../snippet-tests/output/bugholder/Bug.pkl.go | 6 +- .../output/bugholder/BugHolder.pkl.go | 8 +- .../output/bugholder/ThisPerson.pkl.go | 6 +- .../output/cyclicmodule/CyclicModule.pkl.go | 8 +- .../emptyopenmodule/EmptyOpenModule.pkl.go | 16 ++-- .../explicitname/ExplicitlyCoolName.pkl.go | 8 +- .../ExtendsAbstractClass.pkl.go | 8 +- .../output/extendmodule/ExtendModule.pkl.go | 16 ++-- .../extendopenclass/ExtendingOpenClass.pkl.go | 8 +- .../hiddenproperties/HiddenProperties.pkl.go | 8 +- .../output/moduletype/ModuleType.pkl.go | 8 +- .../moduleusinglib/ModuleUsingLib.pkl.go | 8 +- .../output/override/Override.pkl.go | 8 +- .../output/override2/Override2.pkl.go | 16 ++-- .../output/structtags/StructTags.pkl.go | 8 +- .../output/support/lib/Lib.pkl.go | 8 +- .../output/support/lib3/Lib3.pkl.go | 8 +- .../output/support/lib4/Lib4.pkl.go | 8 +- .../output/support/openmodule/MyModule.pkl.go | 16 ++-- .../snippet-tests/output/union/Union.pkl.go | 8 +- .../unionnamekeyword/UnionNameKeyword.pkl.go | 8 +- codegen/src/internal/ClassGen.pkl | 42 +++------- codegen/src/internal/GoMapping.pkl | 4 +- codegen/src/internal/typegen.pkl | 38 ++++----- codegen/src/tests/typegen.pkl | 6 +- pkl/decode_struct.go | 28 +++++-- pkl/decoder.go | 16 ++-- pkl/evaluator_options.go | 3 - pkl/project.go | 20 ++--- pkl/project_test.go | 6 +- pkl/test_fixtures/classes.pkl | 5 ++ pkl/test_fixtures/gen/any/Any.pkl.go | 8 +- pkl/test_fixtures/gen/classes/Classes.pkl.go | 10 +-- .../gen/collections/Collections.pkl.go | 8 +- .../gen/datasize/Datasize.pkl.go | 30 ++++--- .../gen/duration/Duration.pkl.go | 22 +++-- pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go | 10 +-- .../gen/nullables/Nullables.pkl.go | 8 +- .../gen/primitives/Primitives.pkl.go | 8 +- pkl/test_fixtures/gen/unions/Unions.pkl.go | 8 +- .../gen/unknown_type/UnknownType.pkl.go | 8 +- pkl/test_fixtures/msgpack/classes.pkl.msgpack | 2 +- pkl/unmarshal_test.go | 80 ++++++++++--------- 50 files changed, 278 insertions(+), 334 deletions(-) diff --git a/.gitignore b/.gitignore index b473e04..21e8434 100644 --- a/.gitignore +++ b/.gitignore @@ -14,3 +14,4 @@ build/ .out .cicd/ test-results/ +.pkl-lsp diff --git a/cmd/internal/gen-snippets/gen-snippets.go b/cmd/internal/gen-snippets/gen-snippets.go index 247604a..8fa0957 100644 --- a/cmd/internal/gen-snippets/gen-snippets.go +++ b/cmd/internal/gen-snippets/gen-snippets.go @@ -55,7 +55,12 @@ func makeGoCode(evaluator pkl.Evaluator, snippetsDir string) { panic(err) } codegenDir := filepath.Join(snippetsDir, "..") - settings, err := generatorsettings.LoadFromPath(context.Background(), "codegen/snippet-tests/generator-settings.pkl") + + _, filename, _, ok := runtime.Caller(0) + if !ok { + panic("Can't find runtime caller") + } + settings, err := generatorsettings.LoadFromPath(context.Background(), filepath.Join(filename, "../../../../codegen/snippet-tests/generator-settings.pkl")) if err != nil { panic(err) } @@ -72,6 +77,7 @@ func makeGoCode(evaluator pkl.Evaluator, snippetsDir string) { basename := strings.TrimSuffix(filepath.Base(file.Name()), ".pkl") errContents := strings.ReplaceAll(err.Error(), codegenDir, "") errContents = stripLineNumbers(errContents) + os.MkdirAll(outputDir, os.ModePerm) if err = os.WriteFile(filepath.Join(outputDir, basename), []byte(errContents), 0o666); err != nil { panic(err) } diff --git a/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go b/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go index ca8d712..a65e329 100644 --- a/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go +++ b/cmd/pkl-gen-go/generatorsettings/GeneratorSettings.pkl.go @@ -71,11 +71,16 @@ type GeneratorSettings struct { // // This corresponds to the `--project-dir` flag in the Pkl CLI. // Relative paths are resolved against the enclosing file. + // + // Paths must use `/` as the path separator. ProjectDir *string `pkl:"projectDir"` // The cache directory for storing packages. // // This corresponds to the `--cache-dir` flag in the Pkl CLI. + // Relative paths are resolved against the enclosing file. + // + // Paths must use `/` as the path separator. CacheDir *string `pkl:"cacheDir"` // Print out the names of the files that will be generated, but skip writing anything to disk. @@ -86,10 +91,10 @@ type GeneratorSettings struct { } // LoadFromPath loads the pkl module at the given path and evaluates it into a GeneratorSettings -func LoadFromPath(ctx context.Context, path string) (ret *GeneratorSettings, err error) { +func LoadFromPath(ctx context.Context, path string) (ret GeneratorSettings, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return nil, err + return GeneratorSettings{}, err } defer func() { cerr := evaluator.Close() @@ -102,10 +107,8 @@ func LoadFromPath(ctx context.Context, path string) (ret *GeneratorSettings, err } // Load loads the pkl module at the given source and evaluates it with the given evaluator into a GeneratorSettings -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*GeneratorSettings, error) { +func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (GeneratorSettings, error) { var ret GeneratorSettings - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return nil, err - } - return &ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/cmd/pkl-gen-go/pkg/generate.go b/cmd/pkl-gen-go/pkg/generate.go index c5045a3..e2d9c18 100644 --- a/cmd/pkl-gen-go/pkg/generate.go +++ b/cmd/pkl-gen-go/pkg/generate.go @@ -43,7 +43,7 @@ var ( ) type TemplateValues struct { - *generatorsettings.GeneratorSettings + generatorsettings.GeneratorSettings PklModulePath string } @@ -78,7 +78,7 @@ func doFormat(src string) ([]byte, string, error) { return formatted, cmp.Diff(src, strFormatted), nil } -func generateDryRun(evaluator pkl.Evaluator, tmpFile *os.File, outputPath string, settings *generatorsettings.GeneratorSettings) error { +func generateDryRun(evaluator pkl.Evaluator, tmpFile *os.File, outputPath string, settings generatorsettings.GeneratorSettings) error { var filenames []string err := evaluator.EvaluateExpression(context.Background(), pkl.FileSource(tmpFile.Name()), "output.files.toMap().keys.toList()", &filenames) if err != nil { @@ -105,7 +105,7 @@ func log(format string, a ...any) { func GenerateGo( evaluator pkl.Evaluator, pklModulePath string, - settings *generatorsettings.GeneratorSettings, + settings generatorsettings.GeneratorSettings, silent bool, outputPath string, ) error { @@ -124,7 +124,7 @@ func GenerateGo( } log("Using custom generator script: \033[36m%s\033[0m\n", settings.GeneratorScriptPath) } - if err = determineBasePath(settings); err != nil { + if err = determineBasePath(&settings); err != nil { return err } tmpFile, err := os.CreateTemp(os.TempDir(), "pkl-gen-go.*.pkl") diff --git a/cmd/pkl-gen-go/pkl-gen-go.go b/cmd/pkl-gen-go/pkl-gen-go.go index 28dff6a..5d083b1 100644 --- a/cmd/pkl-gen-go/pkl-gen-go.go +++ b/cmd/pkl-gen-go/pkl-gen-go.go @@ -121,7 +121,7 @@ func evaluatorOptions(opts *pkl.EvaluatorOptions) { } var ( - settings *generatorsettings.GeneratorSettings + settings generatorsettings.GeneratorSettings suppressWarnings bool outputPath string printVersion bool @@ -189,7 +189,7 @@ func findProjectDir(projectDirFlag string) string { // Loads the settings for controlling codegen. // Uses a Pkl evaluator that is separate from what's used for actually running codegen. -func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string, cacheDirFlag string) (*generatorsettings.GeneratorSettings, error) { +func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string, cacheDirFlag string) (generatorsettings.GeneratorSettings, error) { projectDir := findProjectDir(projectDirFlag) var evaluator pkl.Evaluator var err error @@ -216,7 +216,7 @@ func loadGeneratorSettings(generatorSettingsPath string, projectDirFlag string, } s, err := generatorsettings.Load(context.Background(), evaluator, source) if err != nil { - return nil, err + return s, err } settingsFilePath := path.Dir(source.Uri.Path) if s.ProjectDir != nil && !path.IsAbs(*s.ProjectDir) { diff --git a/codegen/snippet-tests/input/CyclicModule.pkl b/codegen/snippet-tests/input/CyclicModule.pkl index da622af..0fade72 100644 --- a/codegen/snippet-tests/input/CyclicModule.pkl +++ b/codegen/snippet-tests/input/CyclicModule.pkl @@ -25,5 +25,5 @@ class Cyclic { b: Int - myself: Cyclic + myself: Cyclic? } diff --git a/codegen/snippet-tests/input/ModuleType.pkl b/codegen/snippet-tests/input/ModuleType.pkl index b409c53..2b35e78 100644 --- a/codegen/snippet-tests/input/ModuleType.pkl +++ b/codegen/snippet-tests/input/ModuleType.pkl @@ -21,10 +21,10 @@ import ".../src/go.pkl" myStr: String -foo: module +foo: module? lib: lib4.MyLib4 -fooAgain: Myself +fooAgain: Myself? typealias Myself = module diff --git a/codegen/snippet-tests/output/bugholder/Bug.pkl.go b/codegen/snippet-tests/output/bugholder/Bug.pkl.go index ef6eae9..233b15f 100644 --- a/codegen/snippet-tests/output/bugholder/Bug.pkl.go +++ b/codegen/snippet-tests/output/bugholder/Bug.pkl.go @@ -15,9 +15,9 @@ type Bug struct { Age *int `pkl:"age"` // How long the bug holds its breath for - HoldsBreathFor *pkl.Duration `pkl:"holdsBreathFor"` + HoldsBreathFor pkl.Duration `pkl:"holdsBreathFor"` - Size *pkl.DataSize `pkl:"size"` + Size pkl.DataSize `pkl:"size"` Kind bugkind.BugKind `pkl:"kind"` @@ -27,5 +27,5 @@ type Bug struct { Kind4 string `pkl:"kind4"` - BagOfStuff *pkl.Object `pkl:"bagOfStuff"` + BagOfStuff pkl.Object `pkl:"bagOfStuff"` } diff --git a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go index 0f7fb31..dd93731 100644 --- a/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go +++ b/codegen/snippet-tests/output/bugholder/BugHolder.pkl.go @@ -21,7 +21,7 @@ type BugHolder struct { func LoadFromPath(ctx context.Context, path string) (ret BugHolder, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return BugHolder{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -36,8 +36,6 @@ 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) { var ret BugHolder - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return BugHolder{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go index 39f931c..a1d3c77 100644 --- a/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go +++ b/codegen/snippet-tests/output/bugholder/ThisPerson.pkl.go @@ -4,7 +4,7 @@ package bugholder type ThisPerson interface { Person - GetMyself() *ThisPerson + GetMyself() ThisPerson GetSomeoneElse() Person } @@ -14,12 +14,12 @@ var _ ThisPerson = ThisPersonImpl{} type ThisPersonImpl struct { PersonImpl - Myself *ThisPerson `pkl:"myself"` + Myself ThisPerson `pkl:"myself"` SomeoneElse Person `pkl:"someoneElse"` } -func (rcv ThisPersonImpl) GetMyself() *ThisPerson { +func (rcv ThisPersonImpl) GetMyself() ThisPerson { return rcv.Myself } diff --git a/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go b/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go index 0f4687e..333aa7f 100644 --- a/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go +++ b/codegen/snippet-tests/output/cyclicmodule/CyclicModule.pkl.go @@ -15,7 +15,7 @@ type CyclicModule struct { func LoadFromPath(ctx context.Context, path string) (ret CyclicModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return CyclicModule{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ func LoadFromPath(ctx context.Context, path string) (ret CyclicModule, err error // 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) { var ret CyclicModule - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return CyclicModule{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go index 45acde4..fe35a52 100644 --- a/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go +++ b/codegen/snippet-tests/output/emptyopenmodule/EmptyOpenModule.pkl.go @@ -15,11 +15,11 @@ var _ EmptyOpenModule = EmptyOpenModuleImpl{} type EmptyOpenModuleImpl struct { } -// LoadFromPath loads the pkl module at the given path and evaluates it into a EmptyOpenModuleImpl -func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModuleImpl, err error) { +// 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 EmptyOpenModuleImpl{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -31,11 +31,9 @@ func LoadFromPath(ctx context.Context, path string) (ret EmptyOpenModuleImpl, er return ret, err } -// Load loads the pkl module at the given source and evaluates it with the given evaluator into a EmptyOpenModuleImpl -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (EmptyOpenModuleImpl, error) { +// 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 - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return EmptyOpenModuleImpl{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go b/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go index e11d022..82d6d9b 100644 --- a/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go +++ b/codegen/snippet-tests/output/explicitname/ExplicitlyCoolName.pkl.go @@ -15,7 +15,7 @@ type ExplicitlyCoolName struct { func LoadFromPath(ctx context.Context, path string) (ret ExplicitlyCoolName, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return ExplicitlyCoolName{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ func LoadFromPath(ctx context.Context, path string) (ret ExplicitlyCoolName, err // 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) { var ret ExplicitlyCoolName - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return ExplicitlyCoolName{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go index d2b82de..f5f9706 100644 --- a/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/ExtendsAbstractClass.pkl.go @@ -15,7 +15,7 @@ type ExtendsAbstractClass struct { func LoadFromPath(ctx context.Context, path string) (ret ExtendsAbstractClass, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return ExtendsAbstractClass{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ func LoadFromPath(ctx context.Context, path string) (ret ExtendsAbstractClass, e // 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) { var ret ExtendsAbstractClass - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return ExtendsAbstractClass{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go index 4408520..081e4ff 100644 --- a/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go +++ b/codegen/snippet-tests/output/extendmodule/ExtendModule.pkl.go @@ -26,11 +26,11 @@ func (rcv ExtendModuleImpl) GetBar() string { return rcv.Bar } -// LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendModuleImpl -func LoadFromPath(ctx context.Context, path string) (ret ExtendModuleImpl, err error) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a ExtendModule +func LoadFromPath(ctx context.Context, path string) (ret ExtendModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return ExtendModuleImpl{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -42,11 +42,9 @@ func LoadFromPath(ctx context.Context, path string) (ret ExtendModuleImpl, err e return ret, err } -// Load loads the pkl module at the given source and evaluates it with the given evaluator into a ExtendModuleImpl -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (ExtendModuleImpl, 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 - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return ExtendModuleImpl{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go index 29b5ed7..a7448b6 100644 --- a/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/ExtendingOpenClass.pkl.go @@ -17,7 +17,7 @@ type ExtendingOpenClass struct { func LoadFromPath(ctx context.Context, path string) (ret ExtendingOpenClass, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return ExtendingOpenClass{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -32,8 +32,6 @@ func LoadFromPath(ctx context.Context, path string) (ret ExtendingOpenClass, err // 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) { var ret ExtendingOpenClass - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return ExtendingOpenClass{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go b/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go index 3d87860..4eb18a6 100644 --- a/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go +++ b/codegen/snippet-tests/output/hiddenproperties/HiddenProperties.pkl.go @@ -15,7 +15,7 @@ type HiddenProperties struct { func LoadFromPath(ctx context.Context, path string) (ret HiddenProperties, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return HiddenProperties{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ func LoadFromPath(ctx context.Context, path string) (ret HiddenProperties, err e // 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) { var ret HiddenProperties - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return HiddenProperties{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go b/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go index cec6039..5bebd41 100644 --- a/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go +++ b/codegen/snippet-tests/output/moduletype/ModuleType.pkl.go @@ -22,7 +22,7 @@ type ModuleType struct { func LoadFromPath(ctx context.Context, path string) (ret ModuleType, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return ModuleType{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -37,8 +37,6 @@ 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) { var ret ModuleType - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return ModuleType{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go index ee48135..273340c 100644 --- a/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go +++ b/codegen/snippet-tests/output/moduleusinglib/ModuleUsingLib.pkl.go @@ -24,7 +24,7 @@ type ModuleUsingLib struct { func LoadFromPath(ctx context.Context, path string) (ret ModuleUsingLib, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return ModuleUsingLib{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -39,8 +39,6 @@ func LoadFromPath(ctx context.Context, path string) (ret ModuleUsingLib, err err // 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) { var ret ModuleUsingLib - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return ModuleUsingLib{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/override/Override.pkl.go b/codegen/snippet-tests/output/override/Override.pkl.go index eb7d60e..6ac75f1 100644 --- a/codegen/snippet-tests/output/override/Override.pkl.go +++ b/codegen/snippet-tests/output/override/Override.pkl.go @@ -15,7 +15,7 @@ type Override struct { func LoadFromPath(ctx context.Context, path string) (ret Override, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Override{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ 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) { var ret Override - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Override{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/override2/Override2.pkl.go b/codegen/snippet-tests/output/override2/Override2.pkl.go index e24487c..7271610 100644 --- a/codegen/snippet-tests/output/override2/Override2.pkl.go +++ b/codegen/snippet-tests/output/override2/Override2.pkl.go @@ -23,11 +23,11 @@ func (rcv Override2Impl) GetFoo() string { return rcv.Foo } -// LoadFromPath loads the pkl module at the given path and evaluates it into a Override2Impl -func LoadFromPath(ctx context.Context, path string) (ret Override2Impl, err error) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a Override2 +func LoadFromPath(ctx context.Context, path string) (ret Override2, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Override2Impl{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -39,11 +39,9 @@ func LoadFromPath(ctx context.Context, path string) (ret Override2Impl, err erro return ret, err } -// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Override2Impl -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (Override2Impl, 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 - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Override2Impl{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/structtags/StructTags.pkl.go b/codegen/snippet-tests/output/structtags/StructTags.pkl.go index 653323c..cb77bb4 100644 --- a/codegen/snippet-tests/output/structtags/StructTags.pkl.go +++ b/codegen/snippet-tests/output/structtags/StructTags.pkl.go @@ -35,7 +35,7 @@ type StructTags struct { func LoadFromPath(ctx context.Context, path string) (ret StructTags, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return StructTags{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -50,8 +50,6 @@ 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) { var ret StructTags - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return StructTags{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/support/lib/Lib.pkl.go b/codegen/snippet-tests/output/support/lib/Lib.pkl.go index 94237d7..1d0fb06 100644 --- a/codegen/snippet-tests/output/support/lib/Lib.pkl.go +++ b/codegen/snippet-tests/output/support/lib/Lib.pkl.go @@ -14,7 +14,7 @@ type Lib struct { func LoadFromPath(ctx context.Context, path string) (ret Lib, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Lib{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -29,8 +29,6 @@ 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) { var ret Lib - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Lib{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go b/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go index 497e3b3..caf279d 100644 --- a/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go +++ b/codegen/snippet-tests/output/support/lib3/Lib3.pkl.go @@ -14,7 +14,7 @@ type Lib3 struct { func LoadFromPath(ctx context.Context, path string) (ret Lib3, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Lib3{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -29,8 +29,6 @@ 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) { var ret Lib3 - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Lib3{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go b/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go index c7b2ca9..7f7c070 100644 --- a/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go +++ b/codegen/snippet-tests/output/support/lib4/Lib4.pkl.go @@ -15,7 +15,7 @@ type Lib4 struct { func LoadFromPath(ctx context.Context, path string) (ret Lib4, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Lib4{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ 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) { var ret Lib4 - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Lib4{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go index ab9d362..5868732 100644 --- a/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go +++ b/codegen/snippet-tests/output/support/openmodule/MyModule.pkl.go @@ -21,11 +21,11 @@ func (rcv MyModuleImpl) GetFoo() string { return rcv.Foo } -// LoadFromPath loads the pkl module at the given path and evaluates it into a MyModuleImpl -func LoadFromPath(ctx context.Context, path string) (ret MyModuleImpl, err error) { +// LoadFromPath loads the pkl module at the given path and evaluates it into a MyModule +func LoadFromPath(ctx context.Context, path string) (ret MyModule, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return MyModuleImpl{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -37,11 +37,9 @@ func LoadFromPath(ctx context.Context, path string) (ret MyModuleImpl, err error return ret, err } -// Load loads the pkl module at the given source and evaluates it with the given evaluator into a MyModuleImpl -func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (MyModuleImpl, 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 - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return MyModuleImpl{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/union/Union.pkl.go b/codegen/snippet-tests/output/union/Union.pkl.go index 5f62f3e..408d0c5 100644 --- a/codegen/snippet-tests/output/union/Union.pkl.go +++ b/codegen/snippet-tests/output/union/Union.pkl.go @@ -29,7 +29,7 @@ type Union struct { func LoadFromPath(ctx context.Context, path string) (ret Union, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Union{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -44,8 +44,6 @@ 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) { var ret Union - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Union{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go b/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go index d8e6bbd..ed44174 100644 --- a/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go +++ b/codegen/snippet-tests/output/unionnamekeyword/UnionNameKeyword.pkl.go @@ -16,7 +16,7 @@ type UnionNameKeyword struct { func LoadFromPath(ctx context.Context, path string) (ret UnionNameKeyword, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return UnionNameKeyword{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -31,8 +31,6 @@ func LoadFromPath(ctx context.Context, path string) (ret UnionNameKeyword, err e // 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) { var ret UnionNameKeyword - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return UnionNameKeyword{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/codegen/src/internal/ClassGen.pkl b/codegen/src/internal/ClassGen.pkl index 1482cf8..7761ab7 100644 --- a/codegen/src/internal/ClassGen.pkl +++ b/codegen/src/internal/ClassGen.pkl @@ -56,11 +56,11 @@ contents = new Listing { } when (isModule && !isAbstract) { "" - "// 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) {" + "// 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) {" "\tevaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)" "\tif err != nil {" - "\t\treturn \(classInfo.struct.type.render(classInfo.goPackage)){}, err" + "\t\treturn ret, err" "\t}" "\tdefer func() {" "\t\tcerr := evaluator.Close()" @@ -72,13 +72,11 @@ 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.struct.name)" - "func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (\(classInfo.struct.type.render(classInfo.goPackage)), error) {" + "// 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) {" "\tvar ret \(classInfo.struct.name)" - "\tif err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {" - "\t\treturn \(classInfo.struct.name){}, err" - "\t}" - "\treturn ret, nil" + "\terr := evaluator.EvaluateModule(ctx, source, &ret)" + "\treturn ret, err" "}" } "" @@ -187,15 +185,7 @@ local struct: String = new Listing { when (field.docComment != null) { utils.renderDocComment(field.docComment!!, "\t") } - when (field.type == classInfo.type) { - renderStructField(pklPropertyName, (field) { - type = new Type.Pointer { - elem = field.type - } - }) - } else { - renderStructField(pklPropertyName, field) - } + renderStructField(pklPropertyName, field) } "}" } @@ -218,13 +208,6 @@ 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))" } "}" @@ -275,13 +258,6 @@ 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)" "}" @@ -302,4 +278,4 @@ local class GoStructField { /// The Pkl property behind the field property: reflect.Property -} +} \ No newline at end of file diff --git a/codegen/src/internal/GoMapping.pkl b/codegen/src/internal/GoMapping.pkl index 999bd52..357ca20 100644 --- a/codegen/src/internal/GoMapping.pkl +++ b/codegen/src/internal/GoMapping.pkl @@ -96,9 +96,9 @@ class Class extends GoMapping { || clazz.superclass.reflectee != Typed && clazz.superclass.reflectee != Module ) new Interface { - name = "\(self.name)" + name = self.name type = new Type.Declared { - typeName = outer.name + typeName = self.name importPath = self.goPackage package = self.goPackageShort } diff --git a/codegen/src/internal/typegen.pkl b/codegen/src/internal/typegen.pkl index e467941..faad02a 100644 --- a/codegen/src/internal/typegen.pkl +++ b/codegen/src/internal/typegen.pkl @@ -28,10 +28,10 @@ function generateType( seenMappings: List ): Type = 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 } + 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) @@ -152,31 +152,25 @@ mappedTypes: Mapping = new { [Boolean] = new Type.Declared { typeName = "bool" } [Null] = anyType [Any] = anyType - [Duration] = new Type.Pointer { - elem = new Type.Declared { - package = "pkl" - typeName = "Duration" - importPath = "github.com/apple/pkl-go/pkl" - } + [Duration] = new Type.Declared { + package = "pkl" + typeName = "Duration" + importPath = "github.com/apple/pkl-go/pkl" } [DurationUnit] = new Type.Declared { package = "pkl" typeName = "DurationUnit" importPath = "github.com/apple/pkl-go/pkl" } - [Dynamic] = new Type.Pointer { - elem = new Type.Declared { - package = "pkl" - typeName = "Object" - importPath = "github.com/apple/pkl-go/pkl" - } + [Dynamic] = new Type.Declared { + package = "pkl" + typeName = "Object" + importPath = "github.com/apple/pkl-go/pkl" } - [DataSize] = new Type.Pointer { - elem = new Type.Declared { - package = "pkl" - typeName = "DataSize" - importPath = "github.com/apple/pkl-go/pkl" - } + [DataSize] = new Type.Declared { + package = "pkl" + typeName = "DataSize" + importPath = "github.com/apple/pkl-go/pkl" } [DataSizeUnit] = new Type.Declared { package = "pkl" diff --git a/codegen/src/tests/typegen.pkl b/codegen/src/tests/typegen.pkl index e34f12a..85887b0 100644 --- a/codegen/src/tests/typegen.pkl +++ b/codegen/src/tests/typegen.pkl @@ -80,9 +80,9 @@ facts { generateType(reflect.uint32Type) == "uint32" generateType(reflect.uintType) == "uint" generateType(reflect.anyType) == "any" - generateType(reflect.dynamicType) == "*pkl.Object" - generateType(reflect.dataSizeType) == "*pkl.DataSize" - generateType(reflect.durationType) == "*pkl.Duration" + generateType(reflect.dynamicType) == "pkl.Object" + generateType(reflect.dataSizeType) == "pkl.DataSize" + generateType(reflect.durationType) == "pkl.Duration" } ["maps"] { generateType(reflectedMaps.properties["res1"].type) == "map[string]string" diff --git a/pkl/decode_struct.go b/pkl/decode_struct.go index ad4160d..1b99bc0 100644 --- a/pkl/decode_struct.go +++ b/pkl/decode_struct.go @@ -149,13 +149,8 @@ func (d *decoder) decodeObjectGeneric(moduleUri, name string) (*reflect.Value, e return &ret, nil } -func (d *decoder) decodeTyped(name string, typ reflect.Type) (*reflect.Value, error) { - if t, exists := d.schemas[name]; exists { - // if we have a known schema by name, use that type instead of the input typ. - // this is important if the Pkl value is a subtype of the input type, e.g. - // in polymorphic cases. - typ = t - } else if typ.Kind() != reflect.Struct { +func (d *decoder) doDecodeTyped(name string, typ reflect.Type) (*reflect.Value, error) { + if typ.Kind() != reflect.Struct { return nil, fmt.Errorf("cannot decode Pkl value of type `%s` into Go type `%s`. Define a custom mapping for this using `pkl.RegisterMapping`", name, typ) } out, err := d.getOutputValue(typ) @@ -175,6 +170,25 @@ func (d *decoder) decodeTyped(name string, typ reflect.Type) (*reflect.Value, er return out, nil } +func (d *decoder) decodeTyped(name string, typ reflect.Type) (*reflect.Value, error) { + if t, exists := d.schemas[name]; exists { + // if we have a known schema by name, use that type instead of the input type. + // this is important if the Pkl value is a subtype of the input type, e.g. + // in polymorphic cases. + typ = t + } + if typ.Kind() == reflect.Ptr { + underlying, err := d.doDecodeTyped(name, typ.Elem()) + if err != nil { + return nil, err + } + ret := reflect.New(typ.Elem()) + ret.Elem().Set(*underlying) + return &ret, nil + } + return d.doDecodeTyped(name, typ) +} + func (d *decoder) decodeDuration() (*reflect.Value, error) { value, err := d.dec.DecodeFloat64() if err != nil { diff --git a/pkl/decoder.go b/pkl/decoder.go index 114bc5b..8552549 100644 --- a/pkl/decoder.go +++ b/pkl/decoder.go @@ -117,7 +117,6 @@ func (d *decoder) Decode(typ reflect.Type) (res *reflect.Value, err error) { } func (d *decoder) decodePointer(inType reflect.Type) (*reflect.Value, error) { - ret := reflect.New(inType.Elem()) code, err := d.dec.PeekCode() if err != nil { return nil, err @@ -126,13 +125,18 @@ func (d *decoder) decodePointer(inType reflect.Type) (*reflect.Value, error) { if err = d.dec.Skip(); err != nil { return nil, err } - ret = reflect.Zero(inType) + ret := reflect.Zero(inType) return &ret, nil } val, err := d.Decode(inType.Elem()) if err != nil { return nil, err } + // if the decoded is already a pointer, we can just return it + if val.Kind() == reflect.Ptr { + return val, nil + } + ret := reflect.New(inType.Elem()) ret.Elem().Set(*val) return &ret, nil } @@ -206,13 +210,7 @@ func (d *decoder) decodePklObject(typ reflect.Type) (*reflect.Value, error) { } switch code { case codeObject: - obj, err := d.decodeObject(typ) - if err != nil { - return nil, err - } - ret := reflect.New(obj.Type()) - ret.Elem().Set(*obj) - return &ret, nil + return d.decodeObject(typ) case codeMap: fallthrough case codeMapping: diff --git a/pkl/evaluator_options.go b/pkl/evaluator_options.go index 8063ba8..2648340 100644 --- a/pkl/evaluator_options.go +++ b/pkl/evaluator_options.go @@ -404,9 +404,6 @@ var WithFs = func(fs fs.FS, scheme string) func(opts *EvaluatorOptions) { var WithProjectEvaluatorSettings = func(project *Project) func(opts *EvaluatorOptions) { return func(opts *EvaluatorOptions) { evaluatorSettings := project.EvaluatorSettings - if evaluatorSettings == nil { - return - } opts.Properties = evaluatorSettings.ExternalProperties opts.Env = evaluatorSettings.Env if evaluatorSettings.AllowedModules != nil { diff --git a/pkl/project.go b/pkl/project.go index 3e1c794..f767e02 100644 --- a/pkl/project.go +++ b/pkl/project.go @@ -24,20 +24,20 @@ import ( // needed for mapping Project.RawDependencies, because the value is defined as any. func init() { - RegisterMapping("pkl.Project", Project{}) - RegisterMapping("pkl.Project#RemoteDependency", ProjectRemoteDependency{}) + RegisterMapping("pkl.Project", &Project{}) + RegisterMapping("pkl.Project#RemoteDependency", &ProjectRemoteDependency{}) } // Project is the go representation of pkl.Project. type Project struct { - ProjectFileUri string `pkl:"projectFileUri"` - Package *ProjectPackage `pkl:"package"` - EvaluatorSettings *ProjectEvaluatorSettings `pkl:"evaluatorSettings"` - Tests []string `pkl:"tests"` - Annotations []Object `pkl:"annotations"` + ProjectFileUri string `pkl:"projectFileUri"` + Package *ProjectPackage `pkl:"package"` + EvaluatorSettings ProjectEvaluatorSettings `pkl:"evaluatorSettings"` + Tests []string `pkl:"tests"` + Annotations []Object `pkl:"annotations"` // internal field; use Project.Dependencies instead. - // values are either *Project or *ProjectRemoteDependency + // values are either Project or ProjectRemoteDependency RawDependencies map[string]any `pkl:"dependencies"` dependencies *ProjectDependencies `pkl:"-"` @@ -136,9 +136,9 @@ func LoadProject(context context.Context, path string) (*Project, error) { } func LoadProjectFromEvaluator(context context.Context, ev Evaluator, path string) (*Project, error) { - var proj Project + var proj *Project if err := ev.EvaluateOutputValue(context, FileSource(path), &proj); err != nil { return nil, err } - return &proj, nil + return proj, nil } diff --git a/pkl/project_test.go b/pkl/project_test.go index 3fad79f..10bdd19 100644 --- a/pkl/project_test.go +++ b/pkl/project_test.go @@ -197,7 +197,7 @@ func TestLoadProject(t *testing.T) { t.Run("evaluatorSettings", func(t *testing.T) { fals := false - expectedSettings := &ProjectEvaluatorSettings{ + expectedSettings := ProjectEvaluatorSettings{ Timeout: Duration{ Value: 5, Unit: Minute, @@ -278,7 +278,7 @@ func TestLoadProjectWithProxy(t *testing.T) { project, err := LoadProject(context.Background(), tempDir+"/pigeons/PklProject") if assert.NoError(t, err) { t.Run("evaluatorSettings", func(t *testing.T) { - expectedSettings := &ProjectEvaluatorSettings{ + expectedSettings := ProjectEvaluatorSettings{ Http: &ProjectEvaluatorSettingsHttp{ Proxy: &ProjectEvaluatorSettingsProxy{ Address: &[]string{"http://localhost:80"}[0], @@ -313,7 +313,7 @@ func TestLoadProjectWithExternalReaders(t *testing.T) { project, err := LoadProject(context.Background(), tempDir+"/pigeons/PklProject") if assert.NoError(t, err) { t.Run("evaluatorSettings", func(t *testing.T) { - expectedSettings := &ProjectEvaluatorSettings{ + expectedSettings := ProjectEvaluatorSettings{ ExternalModuleReaders: map[string]ProjectEvaluatorSettingExternalReader{ "scheme1": {Executable: "reader1"}, "scheme2": {Executable: "reader2", Arguments: []string{"with", "args"}}, diff --git a/pkl/test_fixtures/classes.pkl b/pkl/test_fixtures/classes.pkl index bc273d7..0db0aa1 100644 --- a/pkl/test_fixtures/classes.pkl +++ b/pkl/test_fixtures/classes.pkl @@ -24,6 +24,11 @@ animals: Listing = new { new Cat { name = "Millie"; meows = true } } +nullableAnimals: Listing = new { + null + new Greyhound { name = "Uni"; barks = false; canRoach = true } +} + myAnimal: Animal = new Greyhound { name = "Uni" barks = false diff --git a/pkl/test_fixtures/gen/any/Any.pkl.go b/pkl/test_fixtures/gen/any/Any.pkl.go index 5bdccec..a980bac 100644 --- a/pkl/test_fixtures/gen/any/Any.pkl.go +++ b/pkl/test_fixtures/gen/any/Any.pkl.go @@ -19,7 +19,7 @@ type Any struct { func LoadFromPath(ctx context.Context, path string) (ret Any, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Any{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -34,8 +34,6 @@ 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) { var ret Any - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Any{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/classes/Classes.pkl.go b/pkl/test_fixtures/gen/classes/Classes.pkl.go index dd77b5c..80962c5 100644 --- a/pkl/test_fixtures/gen/classes/Classes.pkl.go +++ b/pkl/test_fixtures/gen/classes/Classes.pkl.go @@ -10,6 +10,8 @@ import ( type Classes struct { Animals []Animal `pkl:"animals"` + NullableAnimals []*Animal `pkl:"nullableAnimals"` + MyAnimal Animal `pkl:"myAnimal"` House House `pkl:"house"` @@ -19,7 +21,7 @@ type Classes struct { func LoadFromPath(ctx context.Context, path string) (ret Classes, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Classes{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -34,8 +36,6 @@ 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) { var ret Classes - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Classes{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/collections/Collections.pkl.go b/pkl/test_fixtures/gen/collections/Collections.pkl.go index 0bd737b..557cf61 100644 --- a/pkl/test_fixtures/gen/collections/Collections.pkl.go +++ b/pkl/test_fixtures/gen/collections/Collections.pkl.go @@ -39,7 +39,7 @@ type Collections struct { func LoadFromPath(ctx context.Context, path string) (ret Collections, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Collections{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -54,8 +54,6 @@ 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) { var ret Collections - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Collections{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/datasize/Datasize.pkl.go b/pkl/test_fixtures/gen/datasize/Datasize.pkl.go index 8311399..e44f487 100644 --- a/pkl/test_fixtures/gen/datasize/Datasize.pkl.go +++ b/pkl/test_fixtures/gen/datasize/Datasize.pkl.go @@ -8,27 +8,27 @@ import ( ) type Datasize struct { - Res1 *pkl.DataSize `pkl:"res1"` + Res1 pkl.DataSize `pkl:"res1"` - Res2 *pkl.DataSize `pkl:"res2"` + Res2 pkl.DataSize `pkl:"res2"` - Res3 *pkl.DataSize `pkl:"res3"` + Res3 pkl.DataSize `pkl:"res3"` - Res4 *pkl.DataSize `pkl:"res4"` + Res4 pkl.DataSize `pkl:"res4"` - Res5 *pkl.DataSize `pkl:"res5"` + Res5 pkl.DataSize `pkl:"res5"` - Res6 *pkl.DataSize `pkl:"res6"` + Res6 pkl.DataSize `pkl:"res6"` - Res7 *pkl.DataSize `pkl:"res7"` + Res7 pkl.DataSize `pkl:"res7"` - Res8 *pkl.DataSize `pkl:"res8"` + Res8 pkl.DataSize `pkl:"res8"` - Res9 *pkl.DataSize `pkl:"res9"` + Res9 pkl.DataSize `pkl:"res9"` - Res10 *pkl.DataSize `pkl:"res10"` + Res10 pkl.DataSize `pkl:"res10"` - Res11 *pkl.DataSize `pkl:"res11"` + Res11 pkl.DataSize `pkl:"res11"` Res12 pkl.DataSizeUnit `pkl:"res12"` } @@ -37,7 +37,7 @@ type Datasize struct { func LoadFromPath(ctx context.Context, path string) (ret Datasize, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Datasize{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -52,8 +52,6 @@ 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) { var ret Datasize - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Datasize{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/duration/Duration.pkl.go b/pkl/test_fixtures/gen/duration/Duration.pkl.go index 5b7ad4f..26561c8 100644 --- a/pkl/test_fixtures/gen/duration/Duration.pkl.go +++ b/pkl/test_fixtures/gen/duration/Duration.pkl.go @@ -8,19 +8,19 @@ import ( ) type Duration struct { - Res1 *pkl.Duration `pkl:"res1"` + Res1 pkl.Duration `pkl:"res1"` - Res2 *pkl.Duration `pkl:"res2"` + Res2 pkl.Duration `pkl:"res2"` - Res3 *pkl.Duration `pkl:"res3"` + Res3 pkl.Duration `pkl:"res3"` - Res4 *pkl.Duration `pkl:"res4"` + Res4 pkl.Duration `pkl:"res4"` - Res5 *pkl.Duration `pkl:"res5"` + Res5 pkl.Duration `pkl:"res5"` - Res6 *pkl.Duration `pkl:"res6"` + Res6 pkl.Duration `pkl:"res6"` - Res7 *pkl.Duration `pkl:"res7"` + Res7 pkl.Duration `pkl:"res7"` Res8 pkl.DurationUnit `pkl:"res8"` } @@ -29,7 +29,7 @@ type Duration struct { func LoadFromPath(ctx context.Context, path string) (ret Duration, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Duration{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -44,8 +44,6 @@ 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) { var ret Duration - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Duration{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go b/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go index 4b3a1c2..7c10242 100644 --- a/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go +++ b/pkl/test_fixtures/gen/dynamic/Dynamic.pkl.go @@ -8,14 +8,14 @@ import ( ) type Dynamic struct { - Res1 *pkl.Object `pkl:"res1"` + Res1 pkl.Object `pkl:"res1"` } // 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) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Dynamic{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ 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) { var ret Dynamic - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Dynamic{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/nullables/Nullables.pkl.go b/pkl/test_fixtures/gen/nullables/Nullables.pkl.go index 7ec4cba..7fcdd61 100644 --- a/pkl/test_fixtures/gen/nullables/Nullables.pkl.go +++ b/pkl/test_fixtures/gen/nullables/Nullables.pkl.go @@ -73,7 +73,7 @@ type Nullables struct { func LoadFromPath(ctx context.Context, path string) (ret Nullables, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Nullables{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -88,8 +88,6 @@ 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) { var ret Nullables - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Nullables{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/primitives/Primitives.pkl.go b/pkl/test_fixtures/gen/primitives/Primitives.pkl.go index e28428c..c0db1da 100644 --- a/pkl/test_fixtures/gen/primitives/Primitives.pkl.go +++ b/pkl/test_fixtures/gen/primitives/Primitives.pkl.go @@ -41,7 +41,7 @@ type Primitives struct { func LoadFromPath(ctx context.Context, path string) (ret Primitives, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Primitives{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -56,8 +56,6 @@ 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) { var ret Primitives - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Primitives{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/unions/Unions.pkl.go b/pkl/test_fixtures/gen/unions/Unions.pkl.go index 2c0d099..c6a236a 100644 --- a/pkl/test_fixtures/gen/unions/Unions.pkl.go +++ b/pkl/test_fixtures/gen/unions/Unions.pkl.go @@ -19,7 +19,7 @@ type Unions struct { func LoadFromPath(ctx context.Context, path string) (ret Unions, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return Unions{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -34,8 +34,6 @@ 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) { var ret Unions - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return Unions{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go b/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go index f78c52c..5c147ad 100644 --- a/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go +++ b/pkl/test_fixtures/gen/unknown_type/UnknownType.pkl.go @@ -15,7 +15,7 @@ type UnknownType struct { func LoadFromPath(ctx context.Context, path string) (ret UnknownType, err error) { evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions) if err != nil { - return UnknownType{}, err + return ret, err } defer func() { cerr := evaluator.Close() @@ -30,8 +30,6 @@ 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) { var ret UnknownType - if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil { - return UnknownType{}, err - } - return ret, nil + err := evaluator.EvaluateModule(ctx, source, &ret) + return ret, err } diff --git a/pkl/test_fixtures/msgpack/classes.pkl.msgpack b/pkl/test_fixtures/msgpack/classes.pkl.msgpack index b8f84aa..9e76b12 100644 --- a/pkl/test_fixtures/msgpack/classes.pkl.msgpack +++ b/pkl/test_fixtures/msgpack/classes.pkl.msgpack @@ -1 +1 @@ -classes$pklgo:/pkl/test_fixtures/classes.pklanimalsclasses#Greyhound$pklgo:/pkl/test_fixtures/classes.pklnameUnibarks“breedGreyhoundcanRoachÔclasses#Cat$pklgo:/pkl/test_fixtures/classes.pklnameMilliemeowsÓmyAnimalclasses#Greyhound$pklgo:/pkl/test_fixtures/classes.pklnameUnibarks“breedGreyhoundcanRoachÓhouseclasses#House$pklgo:/pkl/test_fixtures/classes.pklareaГbedroomsbathrooms \ No newline at end of file +classes$pklgo:/pkl/test_fixtures/classes.pklanimalsclasses#Greyhound$pklgo:/pkl/test_fixtures/classes.pklnameUnibarks“breedGreyhoundcanRoachÔclasses#Cat$pklgo:/pkl/test_fixtures/classes.pklnameMilliemeowsÓnullableAnimalsclasses#Greyhound$pklgo:/pkl/test_fixtures/classes.pklnameUnibarks“breedGreyhoundcanRoachÓmyAnimalclasses#Greyhound$pklgo:/pkl/test_fixtures/classes.pklnameUnibarks“breedGreyhoundcanRoachÓhouseclasses#House$pklgo:/pkl/test_fixtures/classes.pklareaГbedroomsbathrooms \ No newline at end of file diff --git a/pkl/unmarshal_test.go b/pkl/unmarshal_test.go index 1826dea..c676d2f 100644 --- a/pkl/unmarshal_test.go +++ b/pkl/unmarshal_test.go @@ -169,31 +169,31 @@ func TestUnmarshall_Collections(t *testing.T) { func TestUnmarshal_Duration(t *testing.T) { var res duration.Duration expected := duration.Duration{ - Res1: &pkl.Duration{ + Res1: pkl.Duration{ Value: 1, Unit: pkl.Nanosecond, }, - Res2: &pkl.Duration{ + Res2: pkl.Duration{ Value: 2, Unit: pkl.Microsecond, }, - Res3: &pkl.Duration{ + Res3: pkl.Duration{ Value: 3, Unit: pkl.Millisecond, }, - Res4: &pkl.Duration{ + Res4: pkl.Duration{ Value: 4, Unit: pkl.Second, }, - Res5: &pkl.Duration{ + Res5: pkl.Duration{ Value: 5, Unit: pkl.Minute, }, - Res6: &pkl.Duration{ + Res6: pkl.Duration{ Value: 6, Unit: pkl.Hour, }, - Res7: &pkl.Duration{ + Res7: pkl.Duration{ Value: 7, Unit: pkl.Day, }, @@ -207,17 +207,17 @@ func TestUnmarshal_Duration(t *testing.T) { func TestUnmarshal_DataSize(t *testing.T) { var res datasize.Datasize expected := datasize.Datasize{ - Res1: &pkl.DataSize{Value: 1, Unit: pkl.Bytes}, - Res2: &pkl.DataSize{Value: 2, Unit: pkl.Kilobytes}, - Res3: &pkl.DataSize{Value: 3, Unit: pkl.Megabytes}, - Res4: &pkl.DataSize{Value: 4, Unit: pkl.Gigabytes}, - Res5: &pkl.DataSize{Value: 5, Unit: pkl.Terabytes}, - Res6: &pkl.DataSize{Value: 6, Unit: pkl.Petabytes}, - Res7: &pkl.DataSize{Value: 7, Unit: pkl.Kibibytes}, - Res8: &pkl.DataSize{Value: 8, Unit: pkl.Mebibytes}, - Res9: &pkl.DataSize{Value: 9, Unit: pkl.Gibibytes}, - Res10: &pkl.DataSize{Value: 10, Unit: pkl.Tebibytes}, - Res11: &pkl.DataSize{Value: 11, Unit: pkl.Pebibytes}, + Res1: pkl.DataSize{Value: 1, Unit: pkl.Bytes}, + Res2: pkl.DataSize{Value: 2, Unit: pkl.Kilobytes}, + Res3: pkl.DataSize{Value: 3, Unit: pkl.Megabytes}, + Res4: pkl.DataSize{Value: 4, Unit: pkl.Gigabytes}, + Res5: pkl.DataSize{Value: 5, Unit: pkl.Terabytes}, + Res6: pkl.DataSize{Value: 6, Unit: pkl.Petabytes}, + Res7: pkl.DataSize{Value: 7, Unit: pkl.Kibibytes}, + Res8: pkl.DataSize{Value: 8, Unit: pkl.Mebibytes}, + Res9: pkl.DataSize{Value: 9, Unit: pkl.Gibibytes}, + Res10: pkl.DataSize{Value: 10, Unit: pkl.Tebibytes}, + Res11: pkl.DataSize{Value: 11, Unit: pkl.Pebibytes}, Res12: pkl.Megabytes, } if assert.NoError(t, pkl.Unmarshal(datasizeInput, &res)) { @@ -279,25 +279,25 @@ func TestUnmarshal_Nullables(t *testing.T) { func TestUnmarshal_Dynamic(t *testing.T) { var res dynamic.Dynamic expected := dynamic.Dynamic{ - Res1: &pkl.Object{ + Res1: pkl.Object{ ModuleUri: "pkl:base", Name: "Dynamic", Properties: map[string]any{ - "res2": &pkl.Object{ + "res2": pkl.Object{ ModuleUri: "pkl:base", Name: "Dynamic", Properties: map[string]any{"res3": 5}, Entries: map[any]any{}, Elements: []any{}, }, - "res5": &dynamic.MyClass{MyValue: 8}, + "res5": dynamic.MyClass{MyValue: 8}, }, Entries: map[any]any{ "res4": 6, 5: 9, }, Elements: []any{ - &dynamic.MyClass{ + dynamic.MyClass{ MyValue: 7, }, }, @@ -309,23 +309,29 @@ func TestUnmarshal_Dynamic(t *testing.T) { } func TestUnmarshal_Classes(t *testing.T) { + var greyhound = classes.GreyhoundImpl{ + DogImpl: classes.DogImpl{ + Name: "Uni", + Barks: false, + Breed: "Greyhound", + }, + CanRoach: true, + } + var animal classes.Animal = greyhound expected := classes.Classes{ - Animals: []classes.IAnimal{ - &classes.Greyhound{ - Dog: classes.Dog{ - Name: "Uni", - Barks: false, - Breed: "Greyhound", - }, - CanRoach: true, - }, - &classes.Cat{ + Animals: []classes.Animal{ + greyhound, + classes.CatImpl{ Name: "Millie", Meows: true, }, }, - MyAnimal: &classes.Greyhound{ - Dog: classes.Dog{ + NullableAnimals: []*classes.Animal{ + nil, + &animal, + }, + MyAnimal: classes.GreyhoundImpl{ + DogImpl: classes.DogImpl{ Name: "Uni", Barks: false, Breed: "Greyhound", @@ -420,15 +426,15 @@ func TestUnmarshal_AnyType(t *testing.T) { } assert.Equal(t, any2.Any{ Res1: []any{ - &any2.Person{ + any2.Person{ Name: "Barney", }, }, - Res2: &any2.Person{ + Res2: any2.Person{ Name: "Bobby", }, Res3: map[any]any{ - "Wilma": &any2.Person{ + "Wilma": any2.Person{ Name: "Wilma", }, }, From b29d6e3130a6db0332b2a438ca270df9f23ae204 Mon Sep 17 00:00:00 2001 From: Dan Chao Date: Wed, 16 Jul 2025 16:43:47 -0700 Subject: [PATCH 5/7] Preserve compatibility with legacy generated code --- cmd/pkl-gen-go/generatorsettings/init.pkl.go | 2 +- .../output/bugholder/init.pkl.go | 18 ++++----- .../output/cyclicmodule/init.pkl.go | 4 +- .../output/emptyopenmodule/init.pkl.go | 2 +- .../output/explicitname/init.pkl.go | 4 +- .../output/extendabstractclass/init.pkl.go | 4 +- .../output/extendmodule/init.pkl.go | 2 +- .../output/extendopenclass/init.pkl.go | 8 ++-- .../output/hiddenproperties/init.pkl.go | 2 +- .../output/moduletype/init.pkl.go | 2 +- .../output/moduleusinglib/init.pkl.go | 2 +- .../snippet-tests/output/override/init.pkl.go | 4 +- .../output/override2/init.pkl.go | 4 +- .../output/structtags/init.pkl.go | 2 +- .../output/support/lib/init.pkl.go | 4 +- .../output/support/lib3/init.pkl.go | 4 +- .../output/support/lib4/init.pkl.go | 4 +- .../output/support/openmodule/init.pkl.go | 2 +- .../snippet-tests/output/union/init.pkl.go | 2 +- .../output/unionnamekeyword/init.pkl.go | 2 +- codegen/src/internal/Package.pkl | 2 +- pkl/evaluator_test.go | 40 +++++++++++++++++++ pkl/schema.go | 14 ++++++- pkl/test_fixtures/gen/any/init.pkl.go | 4 +- pkl/test_fixtures/gen/classes/init.pkl.go | 10 ++--- pkl/test_fixtures/gen/collections/init.pkl.go | 2 +- pkl/test_fixtures/gen/datasize/init.pkl.go | 2 +- pkl/test_fixtures/gen/duration/init.pkl.go | 2 +- pkl/test_fixtures/gen/dynamic/init.pkl.go | 4 +- pkl/test_fixtures/gen/nullables/init.pkl.go | 4 +- pkl/test_fixtures/gen/primitives/init.pkl.go | 2 +- pkl/test_fixtures/gen/unions/init.pkl.go | 2 +- .../gen/unknown_type/init.pkl.go | 2 +- 33 files changed, 109 insertions(+), 59 deletions(-) diff --git a/cmd/pkl-gen-go/generatorsettings/init.pkl.go b/cmd/pkl-gen-go/generatorsettings/init.pkl.go index edef33b..cbf000f 100644 --- a/cmd/pkl-gen-go/generatorsettings/init.pkl.go +++ b/cmd/pkl-gen-go/generatorsettings/init.pkl.go @@ -4,5 +4,5 @@ package generatorsettings import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("pkl.golang.GeneratorSettings", GeneratorSettings{}) + pkl.RegisterStrictMapping("pkl.golang.GeneratorSettings", GeneratorSettings{}) } diff --git a/codegen/snippet-tests/output/bugholder/init.pkl.go b/codegen/snippet-tests/output/bugholder/init.pkl.go index 6194911..4fb0797 100644 --- a/codegen/snippet-tests/output/bugholder/init.pkl.go +++ b/codegen/snippet-tests/output/bugholder/init.pkl.go @@ -4,13 +4,13 @@ package bugholder 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#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.RegisterStrictMapping("org.foo.BugHolder", BugHolder{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#Bug", Bug{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#Person", PersonImpl{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#Bike", Bike{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#Wheel", Wheel{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#ThisPerson", ThisPersonImpl{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#D", DImpl{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#C", CImpl{}) + pkl.RegisterStrictMapping("org.foo.BugHolder#B", BImpl{}) } diff --git a/codegen/snippet-tests/output/cyclicmodule/init.pkl.go b/codegen/snippet-tests/output/cyclicmodule/init.pkl.go index 6df5e7a..b780897 100644 --- a/codegen/snippet-tests/output/cyclicmodule/init.pkl.go +++ b/codegen/snippet-tests/output/cyclicmodule/init.pkl.go @@ -4,6 +4,6 @@ package cyclicmodule import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("CyclicModule", CyclicModule{}) - pkl.RegisterMapping("CyclicModule#Cyclic", Cyclic{}) + pkl.RegisterStrictMapping("CyclicModule", CyclicModule{}) + pkl.RegisterStrictMapping("CyclicModule#Cyclic", Cyclic{}) } diff --git a/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go b/codegen/snippet-tests/output/emptyopenmodule/init.pkl.go index e93cc11..84766e1 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.RegisterStrictMapping("EmptyOpenModule", EmptyOpenModuleImpl{}) } diff --git a/codegen/snippet-tests/output/explicitname/init.pkl.go b/codegen/snippet-tests/output/explicitname/init.pkl.go index 6276cb7..b7a3202 100644 --- a/codegen/snippet-tests/output/explicitname/init.pkl.go +++ b/codegen/snippet-tests/output/explicitname/init.pkl.go @@ -4,6 +4,6 @@ package explicitname import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("ExplicitName", ExplicitlyCoolName{}) - pkl.RegisterMapping("ExplicitName#SomethingFunny", SomethingVeryFunny{}) + pkl.RegisterStrictMapping("ExplicitName", ExplicitlyCoolName{}) + pkl.RegisterStrictMapping("ExplicitName#SomethingFunny", SomethingVeryFunny{}) } diff --git a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go index b81171f..17686cb 100644 --- a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go @@ -4,6 +4,6 @@ package extendabstractclass import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("ExtendsAbstractClass", ExtendsAbstractClass{}) - pkl.RegisterMapping("ExtendsAbstractClass#C", CImpl{}) + pkl.RegisterStrictMapping("ExtendsAbstractClass", ExtendsAbstractClass{}) + pkl.RegisterStrictMapping("ExtendsAbstractClass#B", BImpl{}) } diff --git a/codegen/snippet-tests/output/extendmodule/init.pkl.go b/codegen/snippet-tests/output/extendmodule/init.pkl.go index ec9f22a..3ff107d 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.RegisterStrictMapping("ExtendModule", ExtendModuleImpl{}) } diff --git a/codegen/snippet-tests/output/extendopenclass/init.pkl.go b/codegen/snippet-tests/output/extendopenclass/init.pkl.go index 9a8e3a6..770d95b 100644 --- a/codegen/snippet-tests/output/extendopenclass/init.pkl.go +++ b/codegen/snippet-tests/output/extendopenclass/init.pkl.go @@ -4,8 +4,8 @@ package extendopenclass 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.RegisterStrictMapping("ExtendingOpenClass", ExtendingOpenClass{}) + pkl.RegisterStrictMapping("ExtendingOpenClass#MyClass", MyClassImpl{}) + pkl.RegisterStrictMapping("ExtendingOpenClass#MyOpenClass", MyOpenClassImpl{}) + pkl.RegisterStrictMapping("ExtendingOpenClass#MyClass2", MyClass2Impl{}) } diff --git a/codegen/snippet-tests/output/hiddenproperties/init.pkl.go b/codegen/snippet-tests/output/hiddenproperties/init.pkl.go index bb3d86f..da8e6a3 100644 --- a/codegen/snippet-tests/output/hiddenproperties/init.pkl.go +++ b/codegen/snippet-tests/output/hiddenproperties/init.pkl.go @@ -4,5 +4,5 @@ package hiddenproperties import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("HiddenProperties", HiddenProperties{}) + pkl.RegisterStrictMapping("HiddenProperties", HiddenProperties{}) } diff --git a/codegen/snippet-tests/output/moduletype/init.pkl.go b/codegen/snippet-tests/output/moduletype/init.pkl.go index 3327f60..2e6427d 100644 --- a/codegen/snippet-tests/output/moduletype/init.pkl.go +++ b/codegen/snippet-tests/output/moduletype/init.pkl.go @@ -4,5 +4,5 @@ package moduletype import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("ModuleType", ModuleType{}) + pkl.RegisterStrictMapping("ModuleType", ModuleType{}) } diff --git a/codegen/snippet-tests/output/moduleusinglib/init.pkl.go b/codegen/snippet-tests/output/moduleusinglib/init.pkl.go index 1586561..380d0c5 100644 --- a/codegen/snippet-tests/output/moduleusinglib/init.pkl.go +++ b/codegen/snippet-tests/output/moduleusinglib/init.pkl.go @@ -4,5 +4,5 @@ package moduleusinglib import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("ModuleUsingLib", ModuleUsingLib{}) + pkl.RegisterStrictMapping("ModuleUsingLib", ModuleUsingLib{}) } diff --git a/codegen/snippet-tests/output/override/init.pkl.go b/codegen/snippet-tests/output/override/init.pkl.go index f51b9b5..955b31a 100644 --- a/codegen/snippet-tests/output/override/init.pkl.go +++ b/codegen/snippet-tests/output/override/init.pkl.go @@ -4,6 +4,6 @@ package override import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("override", Override{}) - pkl.RegisterMapping("override#Bar", BarImpl{}) + pkl.RegisterStrictMapping("override", Override{}) + pkl.RegisterStrictMapping("override#Bar", BarImpl{}) } diff --git a/codegen/snippet-tests/output/override2/init.pkl.go b/codegen/snippet-tests/output/override2/init.pkl.go index 921a38e..7d6e524 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.RegisterStrictMapping("Override2", Override2Impl{}) + pkl.RegisterStrictMapping("Override2#MySubclass", MySubclassImpl{}) } diff --git a/codegen/snippet-tests/output/structtags/init.pkl.go b/codegen/snippet-tests/output/structtags/init.pkl.go index aee717b..e8648c0 100644 --- a/codegen/snippet-tests/output/structtags/init.pkl.go +++ b/codegen/snippet-tests/output/structtags/init.pkl.go @@ -4,5 +4,5 @@ package structtags import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("StructTags", StructTags{}) + pkl.RegisterStrictMapping("StructTags", StructTags{}) } diff --git a/codegen/snippet-tests/output/support/lib/init.pkl.go b/codegen/snippet-tests/output/support/lib/init.pkl.go index 599f09e..ce787fc 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", Lib{}) + pkl.RegisterStrictMapping("lib#MyClass", MyClassImpl{}) + pkl.RegisterStrictMapping("lib", Lib{}) } diff --git a/codegen/snippet-tests/output/support/lib3/init.pkl.go b/codegen/snippet-tests/output/support/lib3/init.pkl.go index c0a6088..c5aeab6 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", Lib3{}) + pkl.RegisterStrictMapping("lib3#GoGoGo", GoGoGoImpl{}) + pkl.RegisterStrictMapping("lib3", Lib3{}) } diff --git a/codegen/snippet-tests/output/support/lib4/init.pkl.go b/codegen/snippet-tests/output/support/lib4/init.pkl.go index bde57fc..f88c085 100644 --- a/codegen/snippet-tests/output/support/lib4/init.pkl.go +++ b/codegen/snippet-tests/output/support/lib4/init.pkl.go @@ -4,6 +4,6 @@ package lib4 import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("lib4#MyLib4", MyLib4{}) - pkl.RegisterMapping("lib4", Lib4{}) + pkl.RegisterStrictMapping("lib4#MyLib4", MyLib4{}) + pkl.RegisterStrictMapping("lib4", Lib4{}) } diff --git a/codegen/snippet-tests/output/support/openmodule/init.pkl.go b/codegen/snippet-tests/output/support/openmodule/init.pkl.go index a1e95c5..e58119a 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.RegisterStrictMapping("MyModule", MyModuleImpl{}) } diff --git a/codegen/snippet-tests/output/union/init.pkl.go b/codegen/snippet-tests/output/union/init.pkl.go index 9fdf264..4cd7e70 100644 --- a/codegen/snippet-tests/output/union/init.pkl.go +++ b/codegen/snippet-tests/output/union/init.pkl.go @@ -4,5 +4,5 @@ package union import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("union", Union{}) + pkl.RegisterStrictMapping("union", Union{}) } diff --git a/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go b/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go index 7690ede..d8f63bc 100644 --- a/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go +++ b/codegen/snippet-tests/output/unionnamekeyword/init.pkl.go @@ -4,5 +4,5 @@ package unionnamekeyword import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("UnionNameKeyword", UnionNameKeyword{}) + pkl.RegisterStrictMapping("UnionNameKeyword", UnionNameKeyword{}) } diff --git a/codegen/src/internal/Package.pkl b/codegen/src/internal/Package.pkl index 8948384..8cb8f8f 100644 --- a/codegen/src/internal/Package.pkl +++ b/codegen/src/internal/Package.pkl @@ -94,7 +94,7 @@ local initFile: String = "" "func init() {" for (struct in structs) { - #"\#tpkl.RegisterMapping(\#(utils.toGoString(struct.clazz.reflectee.toString())), \#(struct.name){})"# + #"\#tpkl.RegisterStrictMapping(\#(utils.toGoString(struct.clazz.reflectee.toString())), \#(struct.name){})"# } "}" "" diff --git a/pkl/evaluator_test.go b/pkl/evaluator_test.go index dc86741..166415c 100644 --- a/pkl/evaluator_test.go +++ b/pkl/evaluator_test.go @@ -443,6 +443,46 @@ age = 43 } }) + t.Run("evaluate into legacy pointer-style types", func(t *testing.T) { + type TestLegacyBar struct { + Name string `pkl:"name"` + } + + type TestLegacyType struct { + SomeDuration *Duration `pkl:"someDuration"` + SomePair *Pair[string, string] `pkl:"somePair"` + Bar *TestLegacyBar `pkl:"bar"` + } + + RegisterMapping("TestLegacyType", TestLegacyType{}) + RegisterMapping("TestLegacyType#Bar", TestLegacyBar{}) + ev, err := manager.NewEvaluator(context.Background(), PreconfiguredOptions) + if assert.NoError(t, err) { + var out *TestLegacyType + err = ev.EvaluateModule(context.Background(), TextSource(` +module TestLegacyType + +someDuration = 5.min + +somePair = Pair("one", "two") + +bar = new Bar { name = "Barney" } + +class Bar { + name: String +} +`), &out) + assert.NoError(t, err) + assert.Equal(t, &TestLegacyType{ + SomeDuration: &Duration{5, Minute}, + SomePair: &Pair[string, string]{"one", "two"}, + Bar: &TestLegacyBar{ + Name: "Barney", + }, + }, out) + } + }) + t.Run("concurrent evaluations", func(t *testing.T) { ev, err := manager.NewEvaluator(context.Background(), PreconfiguredOptions) if err != nil { diff --git a/pkl/schema.go b/pkl/schema.go index 9151412..7320c63 100644 --- a/pkl/schema.go +++ b/pkl/schema.go @@ -20,9 +20,19 @@ import "reflect" var schemas = make(map[string]reflect.Type) -// RegisterMapping associates the type given the Pkl name to the corresponding Go type. +// RegisterStrictMapping associates the type given the Pkl name to the corresponding Go type. // //goland:noinspection GoUnusedExportedFunction -func RegisterMapping(name string, value any) { +func RegisterStrictMapping(name string, value any) { schemas[name] = reflect.TypeOf(value) } + +// RegisterMapping is like RegisterStrictMapping, but casts it to a pointer. +// +// This method exists to preserve compatibility with legacy generated code, where object types were generated as +// pointers. +// +//goland:noinspection GoUnusedExportedFunction +func RegisterMapping(name string, value any) { + schemas[name] = reflect.PointerTo(reflect.TypeOf(value)) +} diff --git a/pkl/test_fixtures/gen/any/init.pkl.go b/pkl/test_fixtures/gen/any/init.pkl.go index c522037..d6585ab 100644 --- a/pkl/test_fixtures/gen/any/init.pkl.go +++ b/pkl/test_fixtures/gen/any/init.pkl.go @@ -4,6 +4,6 @@ package any import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("any", Any{}) - pkl.RegisterMapping("any#Person", Person{}) + pkl.RegisterStrictMapping("any", Any{}) + pkl.RegisterStrictMapping("any#Person", Person{}) } diff --git a/pkl/test_fixtures/gen/classes/init.pkl.go b/pkl/test_fixtures/gen/classes/init.pkl.go index 6fd024e..6f54cb5 100644 --- a/pkl/test_fixtures/gen/classes/init.pkl.go +++ b/pkl/test_fixtures/gen/classes/init.pkl.go @@ -4,9 +4,9 @@ package classes 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.RegisterStrictMapping("classes", Classes{}) + pkl.RegisterStrictMapping("classes#House", House{}) + pkl.RegisterStrictMapping("classes#Dog", DogImpl{}) + pkl.RegisterStrictMapping("classes#Greyhound", GreyhoundImpl{}) + pkl.RegisterStrictMapping("classes#Cat", CatImpl{}) } diff --git a/pkl/test_fixtures/gen/collections/init.pkl.go b/pkl/test_fixtures/gen/collections/init.pkl.go index bfd77c7..72859d2 100644 --- a/pkl/test_fixtures/gen/collections/init.pkl.go +++ b/pkl/test_fixtures/gen/collections/init.pkl.go @@ -4,5 +4,5 @@ package collections import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("collections", Collections{}) + pkl.RegisterStrictMapping("collections", Collections{}) } diff --git a/pkl/test_fixtures/gen/datasize/init.pkl.go b/pkl/test_fixtures/gen/datasize/init.pkl.go index 4cb59a0..fe798bc 100644 --- a/pkl/test_fixtures/gen/datasize/init.pkl.go +++ b/pkl/test_fixtures/gen/datasize/init.pkl.go @@ -4,5 +4,5 @@ package datasize import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("datasize", Datasize{}) + pkl.RegisterStrictMapping("datasize", Datasize{}) } diff --git a/pkl/test_fixtures/gen/duration/init.pkl.go b/pkl/test_fixtures/gen/duration/init.pkl.go index 8e54071..7375aca 100644 --- a/pkl/test_fixtures/gen/duration/init.pkl.go +++ b/pkl/test_fixtures/gen/duration/init.pkl.go @@ -4,5 +4,5 @@ package duration import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("duration", Duration{}) + pkl.RegisterStrictMapping("duration", Duration{}) } diff --git a/pkl/test_fixtures/gen/dynamic/init.pkl.go b/pkl/test_fixtures/gen/dynamic/init.pkl.go index e7097c9..2300c90 100644 --- a/pkl/test_fixtures/gen/dynamic/init.pkl.go +++ b/pkl/test_fixtures/gen/dynamic/init.pkl.go @@ -4,6 +4,6 @@ package dynamic import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("dynamic", Dynamic{}) - pkl.RegisterMapping("dynamic#MyClass", MyClass{}) + pkl.RegisterStrictMapping("dynamic", Dynamic{}) + pkl.RegisterStrictMapping("dynamic#MyClass", MyClass{}) } diff --git a/pkl/test_fixtures/gen/nullables/init.pkl.go b/pkl/test_fixtures/gen/nullables/init.pkl.go index cdf0884..d861265 100644 --- a/pkl/test_fixtures/gen/nullables/init.pkl.go +++ b/pkl/test_fixtures/gen/nullables/init.pkl.go @@ -4,6 +4,6 @@ package nullables import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("nullables", Nullables{}) - pkl.RegisterMapping("nullables#MyClass", MyClass{}) + pkl.RegisterStrictMapping("nullables", Nullables{}) + pkl.RegisterStrictMapping("nullables#MyClass", MyClass{}) } diff --git a/pkl/test_fixtures/gen/primitives/init.pkl.go b/pkl/test_fixtures/gen/primitives/init.pkl.go index f639209..62721dd 100644 --- a/pkl/test_fixtures/gen/primitives/init.pkl.go +++ b/pkl/test_fixtures/gen/primitives/init.pkl.go @@ -4,5 +4,5 @@ package primitives import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("primitives", Primitives{}) + pkl.RegisterStrictMapping("primitives", Primitives{}) } diff --git a/pkl/test_fixtures/gen/unions/init.pkl.go b/pkl/test_fixtures/gen/unions/init.pkl.go index 8bcc483..e55b3bb 100644 --- a/pkl/test_fixtures/gen/unions/init.pkl.go +++ b/pkl/test_fixtures/gen/unions/init.pkl.go @@ -4,5 +4,5 @@ package unions import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("unions", Unions{}) + pkl.RegisterStrictMapping("unions", Unions{}) } diff --git a/pkl/test_fixtures/gen/unknown_type/init.pkl.go b/pkl/test_fixtures/gen/unknown_type/init.pkl.go index 3e77691..2659d0a 100644 --- a/pkl/test_fixtures/gen/unknown_type/init.pkl.go +++ b/pkl/test_fixtures/gen/unknown_type/init.pkl.go @@ -4,5 +4,5 @@ package unknowntype import "github.com/apple/pkl-go/pkl" func init() { - pkl.RegisterMapping("unknown_type", UnknownType{}) + pkl.RegisterStrictMapping("unknown_type", UnknownType{}) } From 5ac422849ec484eda7f2e6205b7fb862a671089a Mon Sep 17 00:00:00 2001 From: Dan Chao Date: Wed, 16 Jul 2025 16:50:28 -0700 Subject: [PATCH 6/7] Fix snippets --- .../snippet-tests/output/extendabstractclass/C.pkl.go | 10 +++++----- .../output/extendabstractclass/init.pkl.go | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/codegen/snippet-tests/output/extendabstractclass/C.pkl.go b/codegen/snippet-tests/output/extendabstractclass/C.pkl.go index e3cfb86..926b28f 100644 --- a/codegen/snippet-tests/output/extendabstractclass/C.pkl.go +++ b/codegen/snippet-tests/output/extendabstractclass/C.pkl.go @@ -12,7 +12,7 @@ type C interface { GetD() string } -var _ C = (*CImpl)(nil) +var _ C = CImpl{} type CImpl struct { B string `pkl:"b"` @@ -24,18 +24,18 @@ type CImpl struct { C lib3.GoGoGo `pkl:"c"` } -func (rcv *CImpl) GetB() string { +func (rcv CImpl) GetB() string { return rcv.B } -func (rcv *CImpl) GetD() string { +func (rcv CImpl) GetD() string { return rcv.D } -func (rcv *CImpl) GetE() cities.Cities { +func (rcv CImpl) GetE() cities.Cities { return rcv.E } -func (rcv *CImpl) GetC() lib3.GoGoGo { +func (rcv CImpl) GetC() lib3.GoGoGo { return rcv.C } diff --git a/codegen/snippet-tests/output/extendabstractclass/init.pkl.go b/codegen/snippet-tests/output/extendabstractclass/init.pkl.go index 17686cb..c73e576 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.RegisterStrictMapping("ExtendsAbstractClass", ExtendsAbstractClass{}) - pkl.RegisterStrictMapping("ExtendsAbstractClass#B", BImpl{}) + pkl.RegisterStrictMapping("ExtendsAbstractClass#C", CImpl{}) } From a561d2d9011ceb9aabe9825ebafe4d6772c2d61d Mon Sep 17 00:00:00 2001 From: Dan Chao Date: Wed, 16 Jul 2025 16:54:48 -0700 Subject: [PATCH 7/7] Fix load project --- pkl/project.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkl/project.go b/pkl/project.go index f767e02..2111dac 100644 --- a/pkl/project.go +++ b/pkl/project.go @@ -24,8 +24,8 @@ import ( // needed for mapping Project.RawDependencies, because the value is defined as any. func init() { - RegisterMapping("pkl.Project", &Project{}) - RegisterMapping("pkl.Project#RemoteDependency", &ProjectRemoteDependency{}) + RegisterStrictMapping("pkl.Project", &Project{}) + RegisterStrictMapping("pkl.Project#RemoteDependency", &ProjectRemoteDependency{}) } // Project is the go representation of pkl.Project.