diff --git a/packages/jsii-calc/lib/index.ts b/packages/jsii-calc/lib/index.ts index 5e6f39c2ca..9c487d7c6c 100644 --- a/packages/jsii-calc/lib/index.ts +++ b/packages/jsii-calc/lib/index.ts @@ -25,3 +25,4 @@ export * as cdk16625 from './cdk16625'; export * as jsii3656 from './jsii3656'; export * as anonymous from './anonymous'; +export * as union from './union'; diff --git a/packages/jsii-calc/lib/union.ts b/packages/jsii-calc/lib/union.ts new file mode 100644 index 0000000000..ef4bf22b8f --- /dev/null +++ b/packages/jsii-calc/lib/union.ts @@ -0,0 +1,21 @@ +import { IFriendly } from '@scope/jsii-calc-lib'; + +export interface IResolvable { + resolve(): any; +} + +export class Resolvable implements IResolvable { + private constructor() {} + + public resolve(): any { + return false; + } +} + +export class ConsumesUnion { + public static unionType(param: IResolvable | Resolvable | IFriendly) { + void param; + } + + private constructor() {} +} diff --git a/packages/jsii-calc/test/assembly.jsii b/packages/jsii-calc/test/assembly.jsii index 469a62babe..d392689d96 100644 --- a/packages/jsii-calc/test/assembly.jsii +++ b/packages/jsii-calc/test/assembly.jsii @@ -421,6 +421,13 @@ "line": 4 }, "symbolId": "lib/submodule/returns-param/index:" + }, + "jsii-calc.union": { + "locationInModule": { + "filename": "lib/index.ts", + "line": 28 + }, + "symbolId": "lib/union:" } }, "targets": { @@ -18199,8 +18206,125 @@ "name": "ReturnsSpecialParameter", "namespace": "submodule.returnsparam", "symbolId": "lib/submodule/returns-param/index:ReturnsSpecialParameter" + }, + "jsii-calc.union.ConsumesUnion": { + "assembly": "jsii-calc", + "docs": { + "stability": "stable" + }, + "fqn": "jsii-calc.union.ConsumesUnion", + "kind": "class", + "locationInModule": { + "filename": "lib/union.ts", + "line": 15 + }, + "methods": [ + { + "docs": { + "stability": "stable" + }, + "locationInModule": { + "filename": "lib/union.ts", + "line": 16 + }, + "name": "unionType", + "parameters": [ + { + "name": "param", + "type": { + "union": { + "types": [ + { + "fqn": "jsii-calc.union.IResolvable" + }, + { + "fqn": "jsii-calc.union.Resolvable" + }, + { + "fqn": "@scope/jsii-calc-lib.IFriendly" + } + ] + } + } + } + ], + "static": true + } + ], + "name": "ConsumesUnion", + "namespace": "union", + "symbolId": "lib/union:ConsumesUnion" + }, + "jsii-calc.union.IResolvable": { + "assembly": "jsii-calc", + "docs": { + "stability": "stable" + }, + "fqn": "jsii-calc.union.IResolvable", + "kind": "interface", + "locationInModule": { + "filename": "lib/union.ts", + "line": 3 + }, + "methods": [ + { + "abstract": true, + "docs": { + "stability": "stable" + }, + "locationInModule": { + "filename": "lib/union.ts", + "line": 4 + }, + "name": "resolve", + "returns": { + "type": { + "primitive": "any" + } + } + } + ], + "name": "IResolvable", + "namespace": "union", + "symbolId": "lib/union:IResolvable" + }, + "jsii-calc.union.Resolvable": { + "assembly": "jsii-calc", + "docs": { + "stability": "stable" + }, + "fqn": "jsii-calc.union.Resolvable", + "interfaces": [ + "jsii-calc.union.IResolvable" + ], + "kind": "class", + "locationInModule": { + "filename": "lib/union.ts", + "line": 7 + }, + "methods": [ + { + "docs": { + "stability": "stable" + }, + "locationInModule": { + "filename": "lib/union.ts", + "line": 10 + }, + "name": "resolve", + "overrides": "jsii-calc.union.IResolvable", + "returns": { + "type": { + "primitive": "any" + } + } + } + ], + "name": "Resolvable", + "namespace": "union", + "symbolId": "lib/union:Resolvable" } }, "version": "3.20.120", - "fingerprint": "Ze43eowG9ImRufT3MQ8yO+bW8JzOQlZIYtFsjpc960E=" + "fingerprint": "OaHwYmdPa8tbAJnlREahLGpRaNNBor2aoG04vsA/SvM=" } \ No newline at end of file diff --git a/packages/jsii-pacmak/lib/targets/dotnet/runtime-type-checking.ts b/packages/jsii-pacmak/lib/targets/dotnet/runtime-type-checking.ts index c59e6d3703..04051070b1 100644 --- a/packages/jsii-pacmak/lib/targets/dotnet/runtime-type-checking.ts +++ b/packages/jsii-pacmak/lib/targets/dotnet/runtime-type-checking.ts @@ -172,6 +172,26 @@ abstract class Validation { code.openBlock(`switch (${expression})`); for (const type of types) { validTypes.push(resolver.toDotNetTypeName(type.spec!)); + + /** + * Filter to remove classes and interfaces from a set of type references that + * are implied by another entry in the set. Practically this is meant to remove + * types from a set if a parent type of it is also present in the set, keeping + * only the most generic declaration. + * + * This is useful because the TypeScript compiler and jsii do not guarantee that + * all entries in a type union are unrelated, but the C# compiler treats dead + * code as an error, and will refuse to compile (error CS8120) a patter-matching + * switch case if it cannot be matched (for example, if it matches on a child of + * a type that was previously matched on already). + */ + if ( + (type.type?.isClassType() || type.type?.isInterfaceType()) + && types.some((other) => other !== type && other.type != null && type.type!.extends(other.type)) + ) { + continue; + } + const typeNames = [resolver.toDotNetType(type.spec!)]; if (typeNames[0] === 'double') { // For doubles, we accept any numeric value, really... diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap index 4af83084d1..ee78fe8a21 100644 --- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap +++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-dotnet.test.js.snap @@ -3167,6 +3167,10 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┃ ┣━ 📄 TwoMethodsWithSimilarCapitalization.cs ┃ ┣━ 📄 UmaskCheck.cs ┃ ┣━ 📄 UnaryOperation.cs + ┃ ┣━ 📁 Union + ┃ ┃ ┣━ 📄 ConsumesUnion.cs + ┃ ┃ ┣━ 📄 IResolvable.cs + ┃ ┃ ┗━ 📄 Resolvable.cs ┃ ┣━ 📄 UnionProperties.cs ┃ ┣━ 📄 UpcasingReflectable.cs ┃ ┣━ 📄 UseBundledDependency.cs @@ -19762,6 +19766,105 @@ namespace Amazon.JSII.Tests.CalculatorNamespace `; +exports[`Generated code for "jsii-calc": /dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/Union/ConsumesUnion.cs 1`] = ` +using Amazon.JSII.Runtime.Deputy; + +#pragma warning disable CS0672,CS0809,CS1591 + +namespace Amazon.JSII.Tests.CalculatorNamespace.Union +{ + [JsiiClass(nativeType: typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.ConsumesUnion), fullyQualifiedName: "jsii-calc.union.ConsumesUnion")] + public class ConsumesUnion : DeputyBase + { + /// Used by jsii to construct an instance of this class from a Javascript-owned object reference + /// The Javascript-owned object reference + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected ConsumesUnion(ByRefValue reference): base(reference) + { + } + + /// Used by jsii to construct an instance of this class from DeputyProps + /// The deputy props + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected ConsumesUnion(DeputyProps props): base(props) + { + } + + [JsiiMethod(name: "unionType", parametersJson: "[{\\"name\\":\\"param\\",\\"type\\":{\\"union\\":{\\"types\\":[{\\"fqn\\":\\"jsii-calc.union.IResolvable\\"},{\\"fqn\\":\\"jsii-calc.union.Resolvable\\"},{\\"fqn\\":\\"@scope/jsii-calc-lib.IFriendly\\"}]}}}]")] + public static void UnionType(object param) + { + InvokeStaticVoidMethod(typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.ConsumesUnion), new System.Type[]{typeof(object)}, new object[]{param}); + } + } +} + +`; + +exports[`Generated code for "jsii-calc": /dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/Union/IResolvable.cs 1`] = ` +using Amazon.JSII.Runtime.Deputy; + +#pragma warning disable CS0672,CS0809,CS1591 + +namespace Amazon.JSII.Tests.CalculatorNamespace.Union +{ + [JsiiInterface(nativeType: typeof(IResolvable), fullyQualifiedName: "jsii-calc.union.IResolvable")] + public interface IResolvable + { + [JsiiMethod(name: "resolve", returnsJson: "{\\"type\\":{\\"primitive\\":\\"any\\"}}")] + object Resolve(); + + [JsiiTypeProxy(nativeType: typeof(IResolvable), fullyQualifiedName: "jsii-calc.union.IResolvable")] + internal sealed class _Proxy : DeputyBase, Amazon.JSII.Tests.CalculatorNamespace.Union.IResolvable + { + private _Proxy(ByRefValue reference): base(reference) + { + } + + [JsiiMethod(name: "resolve", returnsJson: "{\\"type\\":{\\"primitive\\":\\"any\\"}}")] + public object Resolve() + { + return InvokeInstanceMethod(new System.Type[]{}, new object[]{})!; + } + } + } +} + +`; + +exports[`Generated code for "jsii-calc": /dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/Union/Resolvable.cs 1`] = ` +using Amazon.JSII.Runtime.Deputy; + +#pragma warning disable CS0672,CS0809,CS1591 + +namespace Amazon.JSII.Tests.CalculatorNamespace.Union +{ + [JsiiClass(nativeType: typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.Resolvable), fullyQualifiedName: "jsii-calc.union.Resolvable")] + public class Resolvable : DeputyBase, Amazon.JSII.Tests.CalculatorNamespace.Union.IResolvable + { + /// Used by jsii to construct an instance of this class from a Javascript-owned object reference + /// The Javascript-owned object reference + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Resolvable(ByRefValue reference): base(reference) + { + } + + /// Used by jsii to construct an instance of this class from DeputyProps + /// The deputy props + [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] + protected Resolvable(DeputyProps props): base(props) + { + } + + [JsiiMethod(name: "resolve", returnsJson: "{\\"type\\":{\\"primitive\\":\\"any\\"}}")] + public virtual object Resolve() + { + return InvokeInstanceMethod(new System.Type[]{}, new object[]{})!; + } + } +} + +`; + exports[`Generated code for "jsii-calc": /dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/UnionProperties.cs 1`] = ` using Amazon.JSII.Runtime.Deputy; @@ -20583,6 +20686,8 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┣━ 📄 StructUnionConsumer.cs.diff ┣━ 📄 StructWithCollectionOfUnionts.cs.diff ┣━ 📄 TopLevelStruct.cs.diff + ┣━ 📁 Union + ┃ ┗━ 📄 ConsumesUnion.cs.diff ┣━ 📄 UnionProperties.cs.diff ┗━ 📄 VariadicTypeUnion.cs.diff `; @@ -21252,6 +21357,38 @@ exports[`Generated code for "jsii-calc": /dotnet/Amazon /// You don't have to pass this. `; +exports[`Generated code for "jsii-calc": /dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/Union/ConsumesUnion.cs.diff 1`] = ` +--- dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/Union/ConsumesUnion.cs --no-runtime-type-checking ++++ dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/Union/ConsumesUnion.cs --runtime-type-checking +@@ -22,9 +22,26 @@ + } + + [JsiiMethod(name: "unionType", parametersJson: "[{\\"name\\":\\"param\\",\\"type\\":{\\"union\\":{\\"types\\":[{\\"fqn\\":\\"jsii-calc.union.IResolvable\\"},{\\"fqn\\":\\"jsii-calc.union.Resolvable\\"},{\\"fqn\\":\\"@scope/jsii-calc-lib.IFriendly\\"}]}}}]")] + public static void UnionType(object param) + { ++ if (Amazon.JSII.Runtime.Configuration.RuntimeTypeChecking) ++ { ++ switch (param) ++ { ++ case Amazon.JSII.Tests.CalculatorNamespace.Union.IResolvable cast_ccaaac: ++ break; ++ case Amazon.JSII.Tests.CalculatorNamespace.LibNamespace.IFriendly cast_ccaaac: ++ break; ++ case Amazon.JSII.Runtime.Deputy.AnonymousObject cast_ccaaac: ++ // Not enough information to type-check... ++ break; ++ case null: ++ throw new System.ArgumentException($"Expected argument {nameof(param)} to be one of: {typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.IResolvable).FullName}, {typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.Resolvable).FullName}, {typeof(Amazon.JSII.Tests.CalculatorNamespace.LibNamespace.IFriendly).FullName}; received null", nameof(param)); ++ default: ++ throw new System.ArgumentException($"Expected argument {nameof(param)} to be one of: {typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.IResolvable).FullName}, {typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.Resolvable).FullName}, {typeof(Amazon.JSII.Tests.CalculatorNamespace.LibNamespace.IFriendly).FullName}; received {param.GetType().FullName}", nameof(param)); ++ } ++ } + InvokeStaticVoidMethod(typeof(Amazon.JSII.Tests.CalculatorNamespace.Union.ConsumesUnion), new System.Type[]{typeof(object)}, new object[]{param}); + } + } + } +`; + exports[`Generated code for "jsii-calc": /dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/UnionProperties.cs.diff 1`] = ` --- dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/UnionProperties.cs --no-runtime-type-checking +++ dotnet/Amazon.JSII.Tests.CalculatorPackageId/Amazon/JSII/Tests/CalculatorNamespace/UnionProperties.cs --runtime-type-checking diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap index ba52978d53..31a419d223 100644 --- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap +++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-go.test.js.snap @@ -2808,6 +2808,11 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┃ ┣━ 📄 submodule_Default.go ┃ ┣━ 📄 submodule_MyClass.go ┃ ┗━ 📄 submodule.go + ┣━ 📁 union + ┃ ┣━ 📄 union_ConsumesUnion.go + ┃ ┣━ 📄 union_IResolvable.go + ┃ ┣━ 📄 union_Resolvable.go + ┃ ┗━ 📄 union.go ┗━ 📄 version `; @@ -24157,6 +24162,144 @@ func (m *jsiiProxy_MyClass) MethodWithSpecialParam(param *param.SpecialParameter } +`; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union.go 1`] = ` +package union + +import ( + "reflect" + + _jsii_ "github.com/aws/jsii-runtime-go/runtime" +) + +func init() { + _jsii_.RegisterClass( + "jsii-calc.union.ConsumesUnion", + reflect.TypeOf((*ConsumesUnion)(nil)).Elem(), + nil, // no members + func() interface{} { + return &jsiiProxy_ConsumesUnion{} + }, + ) + _jsii_.RegisterInterface( + "jsii-calc.union.IResolvable", + reflect.TypeOf((*IResolvable)(nil)).Elem(), + []_jsii_.Member{ + _jsii_.MemberMethod{JsiiMethod: "resolve", GoMethod: "Resolve"}, + }, + func() interface{} { + return &jsiiProxy_IResolvable{} + }, + ) + _jsii_.RegisterClass( + "jsii-calc.union.Resolvable", + reflect.TypeOf((*Resolvable)(nil)).Elem(), + []_jsii_.Member{ + _jsii_.MemberMethod{JsiiMethod: "resolve", GoMethod: "Resolve"}, + }, + func() interface{} { + j := jsiiProxy_Resolvable{} + _jsii_.InitJsiiProxy(&j.jsiiProxy_IResolvable) + return &j + }, + ) +} + +`; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union_ConsumesUnion.go 1`] = ` +package union + +import ( + _jsii_ "github.com/aws/jsii-runtime-go/runtime" + _init_ "github.com/aws/jsii/jsii-calc/go/jsiicalc/v3/jsii" +) + +type ConsumesUnion interface { +} + +// The jsii proxy struct for ConsumesUnion +type jsiiProxy_ConsumesUnion struct { + _ byte // padding +} + +func ConsumesUnion_UnionType(param interface{}) { + _init_.Initialize() + + _jsii_.StaticInvokeVoid( + "jsii-calc.union.ConsumesUnion", + "unionType", + []interface{}{param}, + ) +} + + +`; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union_IResolvable.go 1`] = ` +package union + +import ( + _jsii_ "github.com/aws/jsii-runtime-go/runtime" +) + +type IResolvable interface { + Resolve() interface{} +} + +// The jsii proxy for IResolvable +type jsiiProxy_IResolvable struct { + _ byte // padding +} + +func (i *jsiiProxy_IResolvable) Resolve() interface{} { + var returns interface{} + + _jsii_.Invoke( + i, + "resolve", + nil, // no parameters + &returns, + ) + + return returns +} + + +`; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union_Resolvable.go 1`] = ` +package union + +import ( + _jsii_ "github.com/aws/jsii-runtime-go/runtime" +) + +type Resolvable interface { + IResolvable + Resolve() interface{} +} + +// The jsii proxy struct for Resolvable +type jsiiProxy_Resolvable struct { + jsiiProxy_IResolvable +} + +func (r *jsiiProxy_Resolvable) Resolve() interface{} { + var returns interface{} + + _jsii_.Invoke( + r, + "resolve", + nil, // no parameters + &returns, + ) + + return returns +} + + `; exports[`Generated code for "jsii-calc": /go/jsiicalc/version 1`] = ` @@ -24492,14 +24635,18 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┃ ┣━ 🆕 pythonself_IInterfaceWithSelf__no_runtime_type_checking.go ┃ ┣━ 🆕 pythonself_IInterfaceWithSelf__runtime_type_checks.go ┃ ┗━ 📄 pythonself_IInterfaceWithSelf.go.diff - ┗━ 📁 submodule - ┣━ 📁 isolated - ┃ ┣━ 🆕 isolated_Kwargs__no_runtime_type_checking.go - ┃ ┣━ 🆕 isolated_Kwargs__runtime_type_checks.go - ┃ ┗━ 📄 isolated_Kwargs.go.diff - ┣━ 🆕 submodule_MyClass__no_runtime_type_checking.go - ┣━ 🆕 submodule_MyClass__runtime_type_checks.go - ┗━ 📄 submodule_MyClass.go.diff + ┣━ 📁 submodule + ┃ ┣━ 📁 isolated + ┃ ┃ ┣━ 🆕 isolated_Kwargs__no_runtime_type_checking.go + ┃ ┃ ┣━ 🆕 isolated_Kwargs__runtime_type_checks.go + ┃ ┃ ┗━ 📄 isolated_Kwargs.go.diff + ┃ ┣━ 🆕 submodule_MyClass__no_runtime_type_checking.go + ┃ ┣━ 🆕 submodule_MyClass__runtime_type_checks.go + ┃ ┗━ 📄 submodule_MyClass.go.diff + ┗━ 📁 union + ┣━ 🆕 union_ConsumesUnion__no_runtime_type_checking.go + ┣━ 🆕 union_ConsumesUnion__runtime_type_checks.go + ┗━ 📄 union_ConsumesUnion.go.diff `; exports[`Generated code for "jsii-calc": /go/jsiicalc/anonymous/anonymous_UseOptions.go.diff 1`] = ` @@ -34533,3 +34680,74 @@ exports[`Generated code for "jsii-calc": /go/jsiicalc/s +} + `; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union_ConsumesUnion.go.diff 1`] = ` +--- go/jsiicalc/union/union_ConsumesUnion.go --no-runtime-type-checking ++++ go/jsiicalc/union/union_ConsumesUnion.go --runtime-type-checking +@@ -14,10 +14,13 @@ + } + + func ConsumesUnion_UnionType(param interface{}) { + _init_.Initialize() + ++ if err := validateConsumesUnion_UnionTypeParameters(param); err != nil { ++ panic(err) ++ } + _jsii_.StaticInvokeVoid( + "jsii-calc.union.ConsumesUnion", + "unionType", + []interface{}{param}, + ) +`; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union_ConsumesUnion__no_runtime_type_checking.go.diff 1`] = ` +--- go/jsiicalc/union/union_ConsumesUnion__no_runtime_type_checking.go --no-runtime-type-checking ++++ go/jsiicalc/union/union_ConsumesUnion__no_runtime_type_checking.go --runtime-type-checking +@@ -0,0 +1,11 @@ ++//go:build no_runtime_type_checking ++// +build no_runtime_type_checking ++ ++package union ++ ++// Building without runtime type checking enabled, so all the below just return nil ++ ++func validateConsumesUnion_UnionTypeParameters(param interface{}) error { ++ return nil ++} ++ +`; + +exports[`Generated code for "jsii-calc": /go/jsiicalc/union/union_ConsumesUnion__runtime_type_checks.go.diff 1`] = ` +--- go/jsiicalc/union/union_ConsumesUnion__runtime_type_checks.go --no-runtime-type-checking ++++ go/jsiicalc/union/union_ConsumesUnion__runtime_type_checks.go --runtime-type-checking +@@ -0,0 +1,29 @@ ++//go:build !no_runtime_type_checking ++// +build !no_runtime_type_checking ++ ++package union ++ ++import ( ++ "fmt" ++ ++ _jsii_ "github.com/aws/jsii-runtime-go/runtime" ++) ++ ++func validateConsumesUnion_UnionTypeParameters(param interface{}) error { ++ if param == nil { ++ return fmt.Errorf("parameter param is required, but nil was provided") ++ } ++ switch param.(type) { ++ case IResolvable: ++ // ok ++ case Resolvable: ++ // ok ++ default: ++ if !_jsii_.IsAnonymousProxy(param) { ++ return fmt.Errorf("parameter param must be one of the allowed types: IResolvable, Resolvable; received %#v (a %T)", param, param) ++ } ++ } ++ ++ return nil ++} ++ +`; diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap index a37a2817c5..739ab09073 100644 --- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap +++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-java.test.js.snap @@ -3898,6 +3898,10 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┃ ┣━ 📄 TwoMethodsWithSimilarCapitalization.java ┃ ┣━ 📄 UmaskCheck.java ┃ ┣━ 📄 UnaryOperation.java + ┃ ┣━ 📁 union + ┃ ┃ ┣━ 📄 ConsumesUnion.java + ┃ ┃ ┣━ 📄 IResolvable.java + ┃ ┃ ┗━ 📄 Resolvable.java ┃ ┣━ 📄 UnionProperties.java ┃ ┣━ 📄 UpcasingReflectable.java ┃ ┣━ 📄 UseBundledDependency.java @@ -27588,6 +27592,116 @@ public class ReturnsSpecialParameter extends software.amazon.jsii.JsiiObject { `; +exports[`Generated code for "jsii-calc": /java/src/main/java/software/amazon/jsii/tests/calculator/union/ConsumesUnion.java 1`] = ` +package software.amazon.jsii.tests.calculator.union; + +/** + */ +@javax.annotation.Generated(value = "jsii-pacmak") +@software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) +@software.amazon.jsii.Jsii(module = software.amazon.jsii.tests.calculator.$Module.class, fqn = "jsii-calc.union.ConsumesUnion") +public class ConsumesUnion extends software.amazon.jsii.JsiiObject { + + protected ConsumesUnion(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + protected ConsumesUnion(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) { + super(initializationMode); + } + + /** + * @param param This parameter is required. + */ + @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) + public static void unionType(final @org.jetbrains.annotations.NotNull java.lang.Object param) { + software.amazon.jsii.JsiiObject.jsiiStaticCall(software.amazon.jsii.tests.calculator.union.ConsumesUnion.class, "unionType", software.amazon.jsii.NativeType.VOID, new Object[] { java.util.Objects.requireNonNull(param, "param is required") }); + } +} + +`; + +exports[`Generated code for "jsii-calc": /java/src/main/java/software/amazon/jsii/tests/calculator/union/IResolvable.java 1`] = ` +package software.amazon.jsii.tests.calculator.union; + +/** + */ +@javax.annotation.Generated(value = "jsii-pacmak") +@software.amazon.jsii.Jsii(module = software.amazon.jsii.tests.calculator.$Module.class, fqn = "jsii-calc.union.IResolvable") +@software.amazon.jsii.Jsii.Proxy(IResolvable.Jsii$Proxy.class) +@software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) +public interface IResolvable extends software.amazon.jsii.JsiiSerializable { + + /** + */ + @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) + @org.jetbrains.annotations.NotNull java.lang.Object resolve(); + + /** + * A proxy class which represents a concrete javascript instance of this type. + */ + @software.amazon.jsii.Internal + final class Jsii$Proxy extends software.amazon.jsii.JsiiObject implements software.amazon.jsii.tests.calculator.union.IResolvable.Jsii$Default { + protected Jsii$Proxy(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + /** + */ + @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) + @Override + public final @org.jetbrains.annotations.NotNull java.lang.Object resolve() { + return software.amazon.jsii.Kernel.call(this, "resolve", software.amazon.jsii.NativeType.forClass(java.lang.Object.class)); + } + } + + /** + * Internal default implementation for {@link IResolvable}. + */ + @software.amazon.jsii.Internal + interface Jsii$Default extends IResolvable { + + /** + */ + @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) + @Override + default @org.jetbrains.annotations.NotNull java.lang.Object resolve() { + return software.amazon.jsii.Kernel.call(this, "resolve", software.amazon.jsii.NativeType.forClass(java.lang.Object.class)); + } + } +} + +`; + +exports[`Generated code for "jsii-calc": /java/src/main/java/software/amazon/jsii/tests/calculator/union/Resolvable.java 1`] = ` +package software.amazon.jsii.tests.calculator.union; + +/** + */ +@javax.annotation.Generated(value = "jsii-pacmak") +@software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) +@software.amazon.jsii.Jsii(module = software.amazon.jsii.tests.calculator.$Module.class, fqn = "jsii-calc.union.Resolvable") +public class Resolvable extends software.amazon.jsii.JsiiObject implements software.amazon.jsii.tests.calculator.union.IResolvable { + + protected Resolvable(final software.amazon.jsii.JsiiObjectRef objRef) { + super(objRef); + } + + protected Resolvable(final software.amazon.jsii.JsiiObject.InitializationMode initializationMode) { + super(initializationMode); + } + + /** + */ + @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) + @Override + public @org.jetbrains.annotations.NotNull java.lang.Object resolve() { + return software.amazon.jsii.Kernel.call(this, "resolve", software.amazon.jsii.NativeType.forClass(java.lang.Object.class)); + } +} + +`; + exports[`Generated code for "jsii-calc": /java/src/main/resources/software/amazon/jsii/tests/calculator/$Module.txt 1`] = ` jsii-calc.AbstractClass=software.amazon.jsii.tests.calculator.AbstractClass jsii-calc.AbstractClassBase=software.amazon.jsii.tests.calculator.AbstractClassBase @@ -27870,6 +27984,9 @@ jsii-calc.submodule.nested_submodule.Namespaced=software.amazon.jsii.tests.calcu jsii-calc.submodule.nested_submodule.deeplyNested.INamespaced=software.amazon.jsii.tests.calculator.submodule.nested_submodule.deeply_nested.INamespaced jsii-calc.submodule.param.SpecialParameter=software.amazon.jsii.tests.calculator.submodule.param.SpecialParameter jsii-calc.submodule.returnsparam.ReturnsSpecialParameter=software.amazon.jsii.tests.calculator.submodule.returnsparam.ReturnsSpecialParameter +jsii-calc.union.ConsumesUnion=software.amazon.jsii.tests.calculator.union.ConsumesUnion +jsii-calc.union.IResolvable=software.amazon.jsii.tests.calculator.union.IResolvable +jsii-calc.union.Resolvable=software.amazon.jsii.tests.calculator.union.Resolvable `; @@ -27893,6 +28010,8 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┣━ 📄 ClassWithNestedUnion.java.diff ┣━ 📄 ConfusingToJackson.java.diff ┣━ 📄 StructUnionConsumer.java.diff + ┣━ 📁 union + ┃ ┗━ 📄 ConsumesUnion.java.diff ┗━ 📄 VariadicTypeUnion.java.diff `; @@ -28345,3 +28464,30 @@ exports[`Generated code for "jsii-calc": /java/src/main /** * @param which This parameter is required. `; + +exports[`Generated code for "jsii-calc": /java/src/main/java/software/amazon/jsii/tests/calculator/union/ConsumesUnion.java.diff 1`] = ` +--- java/src/main/java/software/amazon/jsii/tests/calculator/union/ConsumesUnion.java --no-runtime-type-checking ++++ java/src/main/java/software/amazon/jsii/tests/calculator/union/ConsumesUnion.java --runtime-type-checking +@@ -18,8 +18,21 @@ + /** + * @param param This parameter is required. + */ + @software.amazon.jsii.Stability(software.amazon.jsii.Stability.Level.Stable) + public static void unionType(final @org.jetbrains.annotations.NotNull java.lang.Object param) { ++ if (software.amazon.jsii.Configuration.getRuntimeTypeChecking()) { ++ if ( ++ !(param instanceof software.amazon.jsii.tests.calculator.union.IResolvable) ++ && !(param instanceof software.amazon.jsii.tests.calculator.union.Resolvable) ++ && !(param.getClass().equals(software.amazon.jsii.JsiiObject.class)) ++ ) { ++ throw new IllegalArgumentException( ++ new java.lang.StringBuilder("Expected ") ++ .append("param") ++ .append(" to be one of: software.amazon.jsii.tests.calculator.union.IResolvable, software.amazon.jsii.tests.calculator.union.Resolvable; received ") ++ .append(param.getClass()).toString()); ++ } ++ } + software.amazon.jsii.JsiiObject.jsiiStaticCall(software.amazon.jsii.tests.calculator.union.ConsumesUnion.class, "unionType", software.amazon.jsii.NativeType.VOID, new Object[] { java.util.Objects.requireNonNull(param, "param is required") }); + } + } +`; diff --git a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap index d460f782a1..550b29edee 100644 --- a/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap +++ b/packages/jsii-pacmak/test/generated-code/__snapshots__/target-python.test.js.snap @@ -2437,22 +2437,24 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┣━ 📄 py.typed ┣━ 📁 python_self ┃ ┗━ 📄 __init__.py - ┗━ 📁 submodule - ┣━ 📄 __init__.py - ┣━ 📁 back_references - ┃ ┗━ 📄 __init__.py - ┣━ 📁 child - ┃ ┗━ 📄 __init__.py - ┣━ 📁 isolated - ┃ ┗━ 📄 __init__.py - ┣━ 📁 nested_submodule - ┃ ┣━ 📄 __init__.py - ┃ ┗━ 📁 deeply_nested - ┃ ┗━ 📄 __init__.py - ┣━ 📁 param - ┃ ┗━ 📄 __init__.py - ┗━ 📁 returnsparam - ┗━ 📄 __init__.py + ┣━ 📁 submodule + ┃ ┣━ 📄 __init__.py + ┃ ┣━ 📁 back_references + ┃ ┃ ┗━ 📄 __init__.py + ┃ ┣━ 📁 child + ┃ ┃ ┗━ 📄 __init__.py + ┃ ┣━ 📁 isolated + ┃ ┃ ┗━ 📄 __init__.py + ┃ ┣━ 📁 nested_submodule + ┃ ┃ ┣━ 📄 __init__.py + ┃ ┃ ┗━ 📁 deeply_nested + ┃ ┃ ┗━ 📄 __init__.py + ┃ ┣━ 📁 param + ┃ ┃ ┗━ 📄 __init__.py + ┃ ┗━ 📁 returnsparam + ┃ ┗━ 📄 __init__.py + ┗━ 📁 union + ┗━ 📄 __init__.py `; exports[`Generated code for "jsii-calc": /python/LICENSE 1`] = ` @@ -2771,7 +2773,8 @@ kwargs = json.loads( "jsii_calc.submodule.nested_submodule", "jsii_calc.submodule.nested_submodule.deeply_nested", "jsii_calc.submodule.param", - "jsii_calc.submodule.returnsparam" + "jsii_calc.submodule.returnsparam", + "jsii_calc.union" ], "package_data": { "jsii_calc._jsii": [ @@ -11149,6 +11152,7 @@ __all__ = [ "onlystatic", "python_self", "submodule", + "union", ] publication.publish() @@ -11172,6 +11176,7 @@ from . import nodirect from . import onlystatic from . import python_self from . import submodule +from . import union `; @@ -13642,6 +13647,67 @@ publication.publish() `; +exports[`Generated code for "jsii-calc": /python/src/jsii_calc/union/__init__.py 1`] = ` +import abc +import builtins +import datetime +import enum +import typing + +import jsii +import publication +import typing_extensions + +from typeguard import check_type + +from .._jsii import * + + +class ConsumesUnion(metaclass=jsii.JSIIMeta, jsii_type="jsii-calc.union.ConsumesUnion"): + @jsii.member(jsii_name="unionType") + @builtins.classmethod + def union_type(cls, param: typing.Union["IResolvable", "Resolvable"]) -> None: + ''' + :param param: - + ''' + return typing.cast(None, jsii.sinvoke(cls, "unionType", [param])) + + +@jsii.interface(jsii_type="jsii-calc.union.IResolvable") +class IResolvable(typing_extensions.Protocol): + @jsii.member(jsii_name="resolve") + def resolve(self) -> typing.Any: + ... + + +class _IResolvableProxy: + __jsii_type__: typing.ClassVar[str] = "jsii-calc.union.IResolvable" + + @jsii.member(jsii_name="resolve") + def resolve(self) -> typing.Any: + return typing.cast(typing.Any, jsii.invoke(self, "resolve", [])) + +# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface +typing.cast(typing.Any, IResolvable).__jsii_proxy_class__ = lambda : _IResolvableProxy + + +@jsii.implements(IResolvable) +class Resolvable(metaclass=jsii.JSIIMeta, jsii_type="jsii-calc.union.Resolvable"): + @jsii.member(jsii_name="resolve") + def resolve(self) -> typing.Any: + return typing.cast(typing.Any, jsii.invoke(self, "resolve", [])) + + +__all__ = [ + "ConsumesUnion", + "IResolvable", + "Resolvable", +] + +publication.publish() + +`; + exports[`Generated code for "jsii-calc": / 1`] = ` ┗━ 📁 python @@ -13680,14 +13746,16 @@ exports[`Generated code for "jsii-calc": / 1`] = ` ┃ ┗━ 📄 __init__.py.diff ┣━ 📁 python_self ┃ ┗━ 📄 __init__.py.diff - ┗━ 📁 submodule - ┣━ 📄 __init__.py.diff - ┣━ 📁 back_references - ┃ ┗━ 📄 __init__.py.diff - ┣━ 📁 child - ┃ ┗━ 📄 __init__.py.diff - ┗━ 📁 param - ┗━ 📄 __init__.py.diff + ┣━ 📁 submodule + ┃ ┣━ 📄 __init__.py.diff + ┃ ┣━ 📁 back_references + ┃ ┃ ┗━ 📄 __init__.py.diff + ┃ ┣━ 📁 child + ┃ ┃ ┗━ 📄 __init__.py.diff + ┃ ┗━ 📁 param + ┃ ┗━ 📄 __init__.py.diff + ┗━ 📁 union + ┗━ 📄 __init__.py.diff `; exports[`Generated code for "jsii-calc": /python/src/jsii_calc/__init__.py.diff 1`] = ` @@ -17364,3 +17432,22 @@ exports[`Generated code for "jsii-calc": /python/src/js @builtins.property `; + +exports[`Generated code for "jsii-calc": /python/src/jsii_calc/union/__init__.py.diff 1`] = ` +--- python/src/jsii_calc/union/__init__.py --no-runtime-type-checking ++++ python/src/jsii_calc/union/__init__.py --runtime-type-checking +@@ -18,10 +18,13 @@ + @builtins.classmethod + def union_type(cls, param: typing.Union["IResolvable", "Resolvable"]) -> None: + ''' + :param param: - + ''' ++ if __debug__: ++ type_hints = typing.get_type_hints(ConsumesUnion.union_type) ++ check_type(argname="argument param", value=param, expected_type=type_hints["param"]) + return typing.cast(None, jsii.sinvoke(cls, "unionType", [param])) + + + @jsii.interface(jsii_type="jsii-calc.union.IResolvable") + class IResolvable(typing_extensions.Protocol): +`; diff --git a/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap b/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap index cd6aaf77b4..4ac15cf9f7 100644 --- a/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap +++ b/packages/jsii-reflect/test/__snapshots__/jsii-tree.test.js.snap @@ -445,139 +445,159 @@ exports[`jsii-tree --all 1`] = ` │ │ │ └─┬ static staticMethod() method (stable) │ │ │ ├── static │ │ │ └── returns: string - │ │ └─┬ submodule - │ │ ├─┬ submodules - │ │ │ ├─┬ back_references - │ │ │ │ └─┬ types - │ │ │ │ └─┬ interface MyClassReference (stable) - │ │ │ │ └─┬ members - │ │ │ │ └─┬ reference property (stable) - │ │ │ │ ├── abstract - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.MyClass - │ │ │ ├─┬ child - │ │ │ │ └─┬ types - │ │ │ │ ├─┬ class InnerClass (stable) - │ │ │ │ │ └─┬ members - │ │ │ │ │ ├── () initializer (stable) - │ │ │ │ │ └─┬ static staticProp property (stable) - │ │ │ │ │ ├── const - │ │ │ │ │ ├── immutable - │ │ │ │ │ ├── static - │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct - │ │ │ │ ├─┬ class OuterClass (stable) - │ │ │ │ │ └─┬ members - │ │ │ │ │ ├── () initializer (stable) - │ │ │ │ │ └─┬ innerClass property (stable) - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: jsii-calc.submodule.child.InnerClass - │ │ │ │ ├─┬ interface KwargsProps (stable) - │ │ │ │ │ ├─┬ interfaces - │ │ │ │ │ │ └── SomeStruct - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ extra property (stable) - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: Optional - │ │ │ │ ├─┬ interface SomeStruct (stable) - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ prop property (stable) - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeEnum - │ │ │ │ ├─┬ interface Structure (stable) - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ bool property (stable) - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: boolean - │ │ │ │ ├─┬ enum Awesomeness (stable) - │ │ │ │ │ └── AWESOME (stable) - │ │ │ │ ├─┬ enum Goodness (stable) - │ │ │ │ │ ├── PRETTY_GOOD (stable) - │ │ │ │ │ ├── REALLY_GOOD (stable) - │ │ │ │ │ └── AMAZINGLY_GOOD (stable) - │ │ │ │ └─┬ enum SomeEnum (stable) - │ │ │ │ └── SOME (stable) - │ │ │ ├─┬ isolated - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Kwargs (stable) - │ │ │ │ └─┬ members - │ │ │ │ └─┬ static method(props) method (stable) - │ │ │ │ ├── static - │ │ │ │ ├─┬ parameters - │ │ │ │ │ └─┬ props - │ │ │ │ │ └── type: Optional - │ │ │ │ └── returns: boolean - │ │ │ ├─┬ nested_submodule - │ │ │ │ ├─┬ submodules - │ │ │ │ │ └─┬ deeplyNested - │ │ │ │ │ └─┬ types - │ │ │ │ │ └─┬ interface INamespaced (stable) - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ definedAt property (stable) - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: string - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Namespaced (stable) - │ │ │ │ ├── interfaces: INamespaced - │ │ │ │ └─┬ members - │ │ │ │ ├─┬ definedAt property (stable) - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: string - │ │ │ │ └─┬ goodness property (stable) - │ │ │ │ ├── abstract - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.Goodness - │ │ │ ├─┬ param - │ │ │ │ └─┬ types - │ │ │ │ └─┬ interface SpecialParameter (stable) - │ │ │ │ └─┬ members - │ │ │ │ └─┬ value property (stable) - │ │ │ │ ├── abstract - │ │ │ │ ├── immutable - │ │ │ │ └── type: string - │ │ │ └─┬ returnsparam - │ │ │ └─┬ types - │ │ │ └─┬ class ReturnsSpecialParameter (stable) - │ │ │ └─┬ members - │ │ │ ├── () initializer (stable) - │ │ │ └─┬ returnsSpecialParam() method (stable) - │ │ │ └── returns: jsii-calc.submodule.param.SpecialParameter + │ │ ├─┬ submodule + │ │ │ ├─┬ submodules + │ │ │ │ ├─┬ back_references + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ interface MyClassReference (stable) + │ │ │ │ │ └─┬ members + │ │ │ │ │ └─┬ reference property (stable) + │ │ │ │ │ ├── abstract + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.MyClass + │ │ │ │ ├─┬ child + │ │ │ │ │ └─┬ types + │ │ │ │ │ ├─┬ class InnerClass (stable) + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ ├── () initializer (stable) + │ │ │ │ │ │ └─┬ static staticProp property (stable) + │ │ │ │ │ │ ├── const + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ ├── static + │ │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct + │ │ │ │ │ ├─┬ class OuterClass (stable) + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ ├── () initializer (stable) + │ │ │ │ │ │ └─┬ innerClass property (stable) + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: jsii-calc.submodule.child.InnerClass + │ │ │ │ │ ├─┬ interface KwargsProps (stable) + │ │ │ │ │ │ ├─┬ interfaces + │ │ │ │ │ │ │ └── SomeStruct + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ extra property (stable) + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: Optional + │ │ │ │ │ ├─┬ interface SomeStruct (stable) + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ prop property (stable) + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeEnum + │ │ │ │ │ ├─┬ interface Structure (stable) + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ bool property (stable) + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: boolean + │ │ │ │ │ ├─┬ enum Awesomeness (stable) + │ │ │ │ │ │ └── AWESOME (stable) + │ │ │ │ │ ├─┬ enum Goodness (stable) + │ │ │ │ │ │ ├── PRETTY_GOOD (stable) + │ │ │ │ │ │ ├── REALLY_GOOD (stable) + │ │ │ │ │ │ └── AMAZINGLY_GOOD (stable) + │ │ │ │ │ └─┬ enum SomeEnum (stable) + │ │ │ │ │ └── SOME (stable) + │ │ │ │ ├─┬ isolated + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Kwargs (stable) + │ │ │ │ │ └─┬ members + │ │ │ │ │ └─┬ static method(props) method (stable) + │ │ │ │ │ ├── static + │ │ │ │ │ ├─┬ parameters + │ │ │ │ │ │ └─┬ props + │ │ │ │ │ │ └── type: Optional + │ │ │ │ │ └── returns: boolean + │ │ │ │ ├─┬ nested_submodule + │ │ │ │ │ ├─┬ submodules + │ │ │ │ │ │ └─┬ deeplyNested + │ │ │ │ │ │ └─┬ types + │ │ │ │ │ │ └─┬ interface INamespaced (stable) + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ definedAt property (stable) + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: string + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Namespaced (stable) + │ │ │ │ │ ├── interfaces: INamespaced + │ │ │ │ │ └─┬ members + │ │ │ │ │ ├─┬ definedAt property (stable) + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: string + │ │ │ │ │ └─┬ goodness property (stable) + │ │ │ │ │ ├── abstract + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.Goodness + │ │ │ │ ├─┬ param + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ interface SpecialParameter (stable) + │ │ │ │ │ └─┬ members + │ │ │ │ │ └─┬ value property (stable) + │ │ │ │ │ ├── abstract + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: string + │ │ │ │ └─┬ returnsparam + │ │ │ │ └─┬ types + │ │ │ │ └─┬ class ReturnsSpecialParameter (stable) + │ │ │ │ └─┬ members + │ │ │ │ ├── () initializer (stable) + │ │ │ │ └─┬ returnsSpecialParam() method (stable) + │ │ │ │ └── returns: jsii-calc.submodule.param.SpecialParameter + │ │ │ └─┬ types + │ │ │ ├─┬ class MyClass (stable) + │ │ │ │ ├── interfaces: INamespaced + │ │ │ │ └─┬ members + │ │ │ │ ├─┬ (props) initializer (stable) + │ │ │ │ │ └─┬ parameters + │ │ │ │ │ └─┬ props + │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct + │ │ │ │ ├─┬ methodWithSpecialParam(param) method (stable) + │ │ │ │ │ ├─┬ parameters + │ │ │ │ │ │ └─┬ param + │ │ │ │ │ │ └── type: jsii-calc.submodule.param.SpecialParameter + │ │ │ │ │ └── returns: string + │ │ │ │ ├─┬ awesomeness property (stable) + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.Awesomeness + │ │ │ │ ├─┬ definedAt property (stable) + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: string + │ │ │ │ ├─┬ goodness property (stable) + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.Goodness + │ │ │ │ ├─┬ props property (stable) + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct + │ │ │ │ └─┬ allTypes property (stable) + │ │ │ │ └── type: Optional + │ │ │ └─┬ interface Default (stable) + │ │ │ └─┬ members + │ │ │ └─┬ foo property (stable) + │ │ │ ├── abstract + │ │ │ ├── immutable + │ │ │ └── type: number + │ │ └─┬ union │ │ └─┬ types - │ │ ├─┬ class MyClass (stable) - │ │ │ ├── interfaces: INamespaced + │ │ ├─┬ class ConsumesUnion (stable) │ │ │ └─┬ members - │ │ │ ├─┬ (props) initializer (stable) - │ │ │ │ └─┬ parameters - │ │ │ │ └─┬ props - │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct - │ │ │ ├─┬ methodWithSpecialParam(param) method (stable) - │ │ │ │ ├─┬ parameters - │ │ │ │ │ └─┬ param - │ │ │ │ │ └── type: jsii-calc.submodule.param.SpecialParameter - │ │ │ │ └── returns: string - │ │ │ ├─┬ awesomeness property (stable) - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.Awesomeness - │ │ │ ├─┬ definedAt property (stable) - │ │ │ │ ├── immutable - │ │ │ │ └── type: string - │ │ │ ├─┬ goodness property (stable) - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.Goodness - │ │ │ ├─┬ props property (stable) - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct - │ │ │ └─┬ allTypes property (stable) - │ │ │ └── type: Optional - │ │ └─┬ interface Default (stable) + │ │ │ └─┬ static unionType(param) method (stable) + │ │ │ ├── static + │ │ │ ├─┬ parameters + │ │ │ │ └─┬ param + │ │ │ │ └── type: jsii-calc.union.IResolvable | jsii-calc.union.Resolvable | @scope/jsii-calc-lib.IFriendly + │ │ │ └── returns: void + │ │ ├─┬ class Resolvable (stable) + │ │ │ ├── interfaces: IResolvable + │ │ │ └─┬ members + │ │ │ └─┬ resolve() method (stable) + │ │ │ └── returns: any + │ │ └─┬ interface IResolvable (stable) │ │ └─┬ members - │ │ └─┬ foo property (stable) + │ │ └─┬ resolve() method (stable) │ │ ├── abstract - │ │ ├── immutable - │ │ └── type: number + │ │ └── returns: any │ └─┬ types │ ├─┬ class AbstractClass (stable) │ │ ├── base: AbstractClassBase @@ -3648,44 +3668,50 @@ exports[`jsii-tree --inheritance 1`] = ` │ │ ├─┬ onlystatic │ │ │ └─┬ types │ │ │ └── class OnlyStaticMethods - │ │ └─┬ submodule - │ │ ├─┬ submodules - │ │ │ ├─┬ back_references - │ │ │ │ └─┬ types - │ │ │ │ └── interface MyClassReference - │ │ │ ├─┬ child - │ │ │ │ └─┬ types - │ │ │ │ ├── class InnerClass - │ │ │ │ ├── class OuterClass - │ │ │ │ ├─┬ interface KwargsProps - │ │ │ │ │ └─┬ interfaces - │ │ │ │ │ └── SomeStruct - │ │ │ │ ├── interface SomeStruct - │ │ │ │ ├── interface Structure - │ │ │ │ ├── enum Awesomeness - │ │ │ │ ├── enum Goodness - │ │ │ │ └── enum SomeEnum - │ │ │ ├─┬ isolated - │ │ │ │ └─┬ types - │ │ │ │ └── class Kwargs - │ │ │ ├─┬ nested_submodule - │ │ │ │ ├─┬ submodules - │ │ │ │ │ └─┬ deeplyNested - │ │ │ │ │ └─┬ types - │ │ │ │ │ └── interface INamespaced - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Namespaced - │ │ │ │ └── interfaces: INamespaced - │ │ │ ├─┬ param - │ │ │ │ └─┬ types - │ │ │ │ └── interface SpecialParameter - │ │ │ └─┬ returnsparam - │ │ │ └─┬ types - │ │ │ └── class ReturnsSpecialParameter + │ │ ├─┬ submodule + │ │ │ ├─┬ submodules + │ │ │ │ ├─┬ back_references + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── interface MyClassReference + │ │ │ │ ├─┬ child + │ │ │ │ │ └─┬ types + │ │ │ │ │ ├── class InnerClass + │ │ │ │ │ ├── class OuterClass + │ │ │ │ │ ├─┬ interface KwargsProps + │ │ │ │ │ │ └─┬ interfaces + │ │ │ │ │ │ └── SomeStruct + │ │ │ │ │ ├── interface SomeStruct + │ │ │ │ │ ├── interface Structure + │ │ │ │ │ ├── enum Awesomeness + │ │ │ │ │ ├── enum Goodness + │ │ │ │ │ └── enum SomeEnum + │ │ │ │ ├─┬ isolated + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── class Kwargs + │ │ │ │ ├─┬ nested_submodule + │ │ │ │ │ ├─┬ submodules + │ │ │ │ │ │ └─┬ deeplyNested + │ │ │ │ │ │ └─┬ types + │ │ │ │ │ │ └── interface INamespaced + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Namespaced + │ │ │ │ │ └── interfaces: INamespaced + │ │ │ │ ├─┬ param + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── interface SpecialParameter + │ │ │ │ └─┬ returnsparam + │ │ │ │ └─┬ types + │ │ │ │ └── class ReturnsSpecialParameter + │ │ │ └─┬ types + │ │ │ ├─┬ class MyClass + │ │ │ │ └── interfaces: INamespaced + │ │ │ └── interface Default + │ │ └─┬ union │ │ └─┬ types - │ │ ├─┬ class MyClass - │ │ │ └── interfaces: INamespaced - │ │ └── interface Default + │ │ ├── class ConsumesUnion + │ │ ├─┬ class Resolvable + │ │ │ └── interfaces: IResolvable + │ │ └── interface IResolvable │ └─┬ types │ ├─┬ class AbstractClass │ │ ├── base: AbstractClassBase @@ -4259,81 +4285,92 @@ exports[`jsii-tree --members 1`] = ` │ │ │ └─┬ class OnlyStaticMethods │ │ │ └─┬ members │ │ │ └── static staticMethod() method - │ │ └─┬ submodule - │ │ ├─┬ submodules - │ │ │ ├─┬ back_references - │ │ │ │ └─┬ types - │ │ │ │ └─┬ interface MyClassReference - │ │ │ │ └─┬ members - │ │ │ │ └── reference property - │ │ │ ├─┬ child - │ │ │ │ └─┬ types - │ │ │ │ ├─┬ class InnerClass - │ │ │ │ │ └─┬ members - │ │ │ │ │ ├── () initializer - │ │ │ │ │ └── static staticProp property - │ │ │ │ ├─┬ class OuterClass - │ │ │ │ │ └─┬ members - │ │ │ │ │ ├── () initializer - │ │ │ │ │ └── innerClass property - │ │ │ │ ├─┬ interface KwargsProps - │ │ │ │ │ └─┬ members - │ │ │ │ │ └── extra property - │ │ │ │ ├─┬ interface SomeStruct - │ │ │ │ │ └─┬ members - │ │ │ │ │ └── prop property - │ │ │ │ ├─┬ interface Structure - │ │ │ │ │ └─┬ members - │ │ │ │ │ └── bool property - │ │ │ │ ├─┬ enum Awesomeness - │ │ │ │ │ └── AWESOME - │ │ │ │ ├─┬ enum Goodness - │ │ │ │ │ ├── PRETTY_GOOD - │ │ │ │ │ ├── REALLY_GOOD - │ │ │ │ │ └── AMAZINGLY_GOOD - │ │ │ │ └─┬ enum SomeEnum - │ │ │ │ └── SOME - │ │ │ ├─┬ isolated - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Kwargs - │ │ │ │ └─┬ members - │ │ │ │ └── static method(props) method - │ │ │ ├─┬ nested_submodule - │ │ │ │ ├─┬ submodules - │ │ │ │ │ └─┬ deeplyNested - │ │ │ │ │ └─┬ types - │ │ │ │ │ └─┬ interface INamespaced - │ │ │ │ │ └─┬ members - │ │ │ │ │ └── definedAt property - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Namespaced - │ │ │ │ └─┬ members - │ │ │ │ ├── definedAt property - │ │ │ │ └── goodness property - │ │ │ ├─┬ param - │ │ │ │ └─┬ types - │ │ │ │ └─┬ interface SpecialParameter - │ │ │ │ └─┬ members - │ │ │ │ └── value property - │ │ │ └─┬ returnsparam - │ │ │ └─┬ types - │ │ │ └─┬ class ReturnsSpecialParameter - │ │ │ └─┬ members - │ │ │ ├── () initializer - │ │ │ └── returnsSpecialParam() method + │ │ ├─┬ submodule + │ │ │ ├─┬ submodules + │ │ │ │ ├─┬ back_references + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ interface MyClassReference + │ │ │ │ │ └─┬ members + │ │ │ │ │ └── reference property + │ │ │ │ ├─┬ child + │ │ │ │ │ └─┬ types + │ │ │ │ │ ├─┬ class InnerClass + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ ├── () initializer + │ │ │ │ │ │ └── static staticProp property + │ │ │ │ │ ├─┬ class OuterClass + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ ├── () initializer + │ │ │ │ │ │ └── innerClass property + │ │ │ │ │ ├─┬ interface KwargsProps + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └── extra property + │ │ │ │ │ ├─┬ interface SomeStruct + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └── prop property + │ │ │ │ │ ├─┬ interface Structure + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └── bool property + │ │ │ │ │ ├─┬ enum Awesomeness + │ │ │ │ │ │ └── AWESOME + │ │ │ │ │ ├─┬ enum Goodness + │ │ │ │ │ │ ├── PRETTY_GOOD + │ │ │ │ │ │ ├── REALLY_GOOD + │ │ │ │ │ │ └── AMAZINGLY_GOOD + │ │ │ │ │ └─┬ enum SomeEnum + │ │ │ │ │ └── SOME + │ │ │ │ ├─┬ isolated + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Kwargs + │ │ │ │ │ └─┬ members + │ │ │ │ │ └── static method(props) method + │ │ │ │ ├─┬ nested_submodule + │ │ │ │ │ ├─┬ submodules + │ │ │ │ │ │ └─┬ deeplyNested + │ │ │ │ │ │ └─┬ types + │ │ │ │ │ │ └─┬ interface INamespaced + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └── definedAt property + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Namespaced + │ │ │ │ │ └─┬ members + │ │ │ │ │ ├── definedAt property + │ │ │ │ │ └── goodness property + │ │ │ │ ├─┬ param + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ interface SpecialParameter + │ │ │ │ │ └─┬ members + │ │ │ │ │ └── value property + │ │ │ │ └─┬ returnsparam + │ │ │ │ └─┬ types + │ │ │ │ └─┬ class ReturnsSpecialParameter + │ │ │ │ └─┬ members + │ │ │ │ ├── () initializer + │ │ │ │ └── returnsSpecialParam() method + │ │ │ └─┬ types + │ │ │ ├─┬ class MyClass + │ │ │ │ └─┬ members + │ │ │ │ ├── (props) initializer + │ │ │ │ ├── methodWithSpecialParam(param) method + │ │ │ │ ├── awesomeness property + │ │ │ │ ├── definedAt property + │ │ │ │ ├── goodness property + │ │ │ │ ├── props property + │ │ │ │ └── allTypes property + │ │ │ └─┬ interface Default + │ │ │ └─┬ members + │ │ │ └── foo property + │ │ └─┬ union │ │ └─┬ types - │ │ ├─┬ class MyClass + │ │ ├─┬ class ConsumesUnion │ │ │ └─┬ members - │ │ │ ├── (props) initializer - │ │ │ ├── methodWithSpecialParam(param) method - │ │ │ ├── awesomeness property - │ │ │ ├── definedAt property - │ │ │ ├── goodness property - │ │ │ ├── props property - │ │ │ └── allTypes property - │ │ └─┬ interface Default + │ │ │ └── static unionType(param) method + │ │ ├─┬ class Resolvable + │ │ │ └─┬ members + │ │ │ └── resolve() method + │ │ └─┬ interface IResolvable │ │ └─┬ members - │ │ └── foo property + │ │ └── resolve() method │ └─┬ types │ ├─┬ class AbstractClass │ │ └─┬ members @@ -5639,16 +5676,17 @@ exports[`jsii-tree --signatures 1`] = ` │ │ ├── sub1 │ │ └── sub2 │ ├── onlystatic - │ └─┬ submodule - │ └─┬ submodules - │ ├── back_references - │ ├── child - │ ├── isolated - │ ├─┬ nested_submodule - │ │ └─┬ submodules - │ │ └── deeplyNested - │ ├── param - │ └── returnsparam + │ ├─┬ submodule + │ │ └─┬ submodules + │ │ ├── back_references + │ │ ├── child + │ │ ├── isolated + │ │ ├─┬ nested_submodule + │ │ │ └─┬ submodules + │ │ │ └── deeplyNested + │ │ ├── param + │ │ └── returnsparam + │ └── union ├── @scope/jsii-calc-base ├── @scope/jsii-calc-base-of-base └─┬ @scope/jsii-calc-lib @@ -5763,40 +5801,45 @@ exports[`jsii-tree --types 1`] = ` │ │ ├─┬ onlystatic │ │ │ └─┬ types │ │ │ └── class OnlyStaticMethods - │ │ └─┬ submodule - │ │ ├─┬ submodules - │ │ │ ├─┬ back_references - │ │ │ │ └─┬ types - │ │ │ │ └── interface MyClassReference - │ │ │ ├─┬ child - │ │ │ │ └─┬ types - │ │ │ │ ├── class InnerClass - │ │ │ │ ├── class OuterClass - │ │ │ │ ├── interface KwargsProps - │ │ │ │ ├── interface SomeStruct - │ │ │ │ ├── interface Structure - │ │ │ │ ├── enum Awesomeness - │ │ │ │ ├── enum Goodness - │ │ │ │ └── enum SomeEnum - │ │ │ ├─┬ isolated - │ │ │ │ └─┬ types - │ │ │ │ └── class Kwargs - │ │ │ ├─┬ nested_submodule - │ │ │ │ ├─┬ submodules - │ │ │ │ │ └─┬ deeplyNested - │ │ │ │ │ └─┬ types - │ │ │ │ │ └── interface INamespaced - │ │ │ │ └─┬ types - │ │ │ │ └── class Namespaced - │ │ │ ├─┬ param - │ │ │ │ └─┬ types - │ │ │ │ └── interface SpecialParameter - │ │ │ └─┬ returnsparam - │ │ │ └─┬ types - │ │ │ └── class ReturnsSpecialParameter + │ │ ├─┬ submodule + │ │ │ ├─┬ submodules + │ │ │ │ ├─┬ back_references + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── interface MyClassReference + │ │ │ │ ├─┬ child + │ │ │ │ │ └─┬ types + │ │ │ │ │ ├── class InnerClass + │ │ │ │ │ ├── class OuterClass + │ │ │ │ │ ├── interface KwargsProps + │ │ │ │ │ ├── interface SomeStruct + │ │ │ │ │ ├── interface Structure + │ │ │ │ │ ├── enum Awesomeness + │ │ │ │ │ ├── enum Goodness + │ │ │ │ │ └── enum SomeEnum + │ │ │ │ ├─┬ isolated + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── class Kwargs + │ │ │ │ ├─┬ nested_submodule + │ │ │ │ │ ├─┬ submodules + │ │ │ │ │ │ └─┬ deeplyNested + │ │ │ │ │ │ └─┬ types + │ │ │ │ │ │ └── interface INamespaced + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── class Namespaced + │ │ │ │ ├─┬ param + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── interface SpecialParameter + │ │ │ │ └─┬ returnsparam + │ │ │ │ └─┬ types + │ │ │ │ └── class ReturnsSpecialParameter + │ │ │ └─┬ types + │ │ │ ├── class MyClass + │ │ │ └── interface Default + │ │ └─┬ union │ │ └─┬ types - │ │ ├── class MyClass - │ │ └── interface Default + │ │ ├── class ConsumesUnion + │ │ ├── class Resolvable + │ │ └── interface IResolvable │ └─┬ types │ ├── class AbstractClass │ ├── class AbstractClassBase @@ -6089,16 +6132,17 @@ exports[`jsii-tree 1`] = ` │ │ ├── sub1 │ │ └── sub2 │ ├── onlystatic - │ └─┬ submodule - │ └─┬ submodules - │ ├── back_references - │ ├── child - │ ├── isolated - │ ├─┬ nested_submodule - │ │ └─┬ submodules - │ │ └── deeplyNested - │ ├── param - │ └── returnsparam + │ ├─┬ submodule + │ │ └─┬ submodules + │ │ ├── back_references + │ │ ├── child + │ │ ├── isolated + │ │ ├─┬ nested_submodule + │ │ │ └─┬ submodules + │ │ │ └── deeplyNested + │ │ ├── param + │ │ └── returnsparam + │ └── union ├── @scope/jsii-calc-base ├── @scope/jsii-calc-base-of-base └─┬ @scope/jsii-calc-lib diff --git a/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap b/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap index e5fcf52c5a..e3d1791aee 100644 --- a/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap +++ b/packages/jsii-reflect/test/__snapshots__/tree.test.js.snap @@ -34,16 +34,17 @@ exports[`defaults 1`] = ` │ │ ├── sub1 │ │ └── sub2 │ ├── onlystatic - │ └─┬ submodule - │ └─┬ submodules - │ ├── back_references - │ ├── child - │ ├── isolated - │ ├─┬ nested_submodule - │ │ └─┬ submodules - │ │ └── deeplyNested - │ ├── param - │ └── returnsparam + │ ├─┬ submodule + │ │ └─┬ submodules + │ │ ├── back_references + │ │ ├── child + │ │ ├── isolated + │ │ ├─┬ nested_submodule + │ │ │ └─┬ submodules + │ │ │ └── deeplyNested + │ │ ├── param + │ │ └── returnsparam + │ └── union ├── @scope/jsii-calc-base ├── @scope/jsii-calc-base-of-base └─┬ @scope/jsii-calc-lib @@ -86,16 +87,17 @@ exports[`inheritance 1`] = ` │ │ ├── sub1 │ │ └── sub2 │ ├── onlystatic - │ └─┬ submodule - │ └─┬ submodules - │ ├── back_references - │ ├── child - │ ├── isolated - │ ├─┬ nested_submodule - │ │ └─┬ submodules - │ │ └── deeplyNested - │ ├── param - │ └── returnsparam + │ ├─┬ submodule + │ │ └─┬ submodules + │ │ ├── back_references + │ │ ├── child + │ │ ├── isolated + │ │ ├─┬ nested_submodule + │ │ │ └─┬ submodules + │ │ │ └── deeplyNested + │ │ ├── param + │ │ └── returnsparam + │ └── union ├── @scope/jsii-calc-base ├── @scope/jsii-calc-base-of-base └─┬ @scope/jsii-calc-lib @@ -138,16 +140,17 @@ exports[`members 1`] = ` │ │ ├── sub1 │ │ └── sub2 │ ├── onlystatic - │ └─┬ submodule - │ └─┬ submodules - │ ├── back_references - │ ├── child - │ ├── isolated - │ ├─┬ nested_submodule - │ │ └─┬ submodules - │ │ └── deeplyNested - │ ├── param - │ └── returnsparam + │ ├─┬ submodule + │ │ └─┬ submodules + │ │ ├── back_references + │ │ ├── child + │ │ ├── isolated + │ │ ├─┬ nested_submodule + │ │ │ └─┬ submodules + │ │ │ └── deeplyNested + │ │ ├── param + │ │ └── returnsparam + │ └── union ├── @scope/jsii-calc-base ├── @scope/jsii-calc-base-of-base └─┬ @scope/jsii-calc-lib @@ -601,139 +604,159 @@ exports[`showAll 1`] = ` │ │ │ └─┬ static staticMethod() method │ │ │ ├── static │ │ │ └── returns: string - │ │ └─┬ submodule - │ │ ├─┬ submodules - │ │ │ ├─┬ back_references - │ │ │ │ └─┬ types - │ │ │ │ └─┬ interface MyClassReference - │ │ │ │ └─┬ members - │ │ │ │ └─┬ reference property - │ │ │ │ ├── abstract - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.MyClass - │ │ │ ├─┬ child - │ │ │ │ └─┬ types - │ │ │ │ ├─┬ class InnerClass - │ │ │ │ │ └─┬ members - │ │ │ │ │ ├── () initializer - │ │ │ │ │ └─┬ static staticProp property - │ │ │ │ │ ├── const - │ │ │ │ │ ├── immutable - │ │ │ │ │ ├── static - │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct - │ │ │ │ ├─┬ class OuterClass - │ │ │ │ │ └─┬ members - │ │ │ │ │ ├── () initializer - │ │ │ │ │ └─┬ innerClass property - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: jsii-calc.submodule.child.InnerClass - │ │ │ │ ├─┬ interface KwargsProps - │ │ │ │ │ ├─┬ interfaces - │ │ │ │ │ │ └── SomeStruct - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ extra property - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: Optional - │ │ │ │ ├─┬ interface SomeStruct - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ prop property - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeEnum - │ │ │ │ ├─┬ interface Structure - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ bool property - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: boolean - │ │ │ │ ├─┬ enum Awesomeness - │ │ │ │ │ └── AWESOME - │ │ │ │ ├─┬ enum Goodness - │ │ │ │ │ ├── PRETTY_GOOD - │ │ │ │ │ ├── REALLY_GOOD - │ │ │ │ │ └── AMAZINGLY_GOOD - │ │ │ │ └─┬ enum SomeEnum - │ │ │ │ └── SOME - │ │ │ ├─┬ isolated - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Kwargs - │ │ │ │ └─┬ members - │ │ │ │ └─┬ static method(props) method - │ │ │ │ ├── static - │ │ │ │ ├─┬ parameters - │ │ │ │ │ └─┬ props - │ │ │ │ │ └── type: Optional - │ │ │ │ └── returns: boolean - │ │ │ ├─┬ nested_submodule - │ │ │ │ ├─┬ submodules - │ │ │ │ │ └─┬ deeplyNested - │ │ │ │ │ └─┬ types - │ │ │ │ │ └─┬ interface INamespaced - │ │ │ │ │ └─┬ members - │ │ │ │ │ └─┬ definedAt property - │ │ │ │ │ ├── abstract - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: string - │ │ │ │ └─┬ types - │ │ │ │ └─┬ class Namespaced - │ │ │ │ ├── interfaces: INamespaced - │ │ │ │ └─┬ members - │ │ │ │ ├─┬ definedAt property - │ │ │ │ │ ├── immutable - │ │ │ │ │ └── type: string - │ │ │ │ └─┬ goodness property - │ │ │ │ ├── abstract - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.Goodness - │ │ │ ├─┬ param - │ │ │ │ └─┬ types - │ │ │ │ └─┬ interface SpecialParameter - │ │ │ │ └─┬ members - │ │ │ │ └─┬ value property - │ │ │ │ ├── abstract - │ │ │ │ ├── immutable - │ │ │ │ └── type: string - │ │ │ └─┬ returnsparam - │ │ │ └─┬ types - │ │ │ └─┬ class ReturnsSpecialParameter - │ │ │ └─┬ members - │ │ │ ├── () initializer - │ │ │ └─┬ returnsSpecialParam() method - │ │ │ └── returns: jsii-calc.submodule.param.SpecialParameter + │ │ ├─┬ submodule + │ │ │ ├─┬ submodules + │ │ │ │ ├─┬ back_references + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ interface MyClassReference + │ │ │ │ │ └─┬ members + │ │ │ │ │ └─┬ reference property + │ │ │ │ │ ├── abstract + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.MyClass + │ │ │ │ ├─┬ child + │ │ │ │ │ └─┬ types + │ │ │ │ │ ├─┬ class InnerClass + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ ├── () initializer + │ │ │ │ │ │ └─┬ static staticProp property + │ │ │ │ │ │ ├── const + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ ├── static + │ │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct + │ │ │ │ │ ├─┬ class OuterClass + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ ├── () initializer + │ │ │ │ │ │ └─┬ innerClass property + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: jsii-calc.submodule.child.InnerClass + │ │ │ │ │ ├─┬ interface KwargsProps + │ │ │ │ │ │ ├─┬ interfaces + │ │ │ │ │ │ │ └── SomeStruct + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ extra property + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: Optional + │ │ │ │ │ ├─┬ interface SomeStruct + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ prop property + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeEnum + │ │ │ │ │ ├─┬ interface Structure + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ bool property + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: boolean + │ │ │ │ │ ├─┬ enum Awesomeness + │ │ │ │ │ │ └── AWESOME + │ │ │ │ │ ├─┬ enum Goodness + │ │ │ │ │ │ ├── PRETTY_GOOD + │ │ │ │ │ │ ├── REALLY_GOOD + │ │ │ │ │ │ └── AMAZINGLY_GOOD + │ │ │ │ │ └─┬ enum SomeEnum + │ │ │ │ │ └── SOME + │ │ │ │ ├─┬ isolated + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Kwargs + │ │ │ │ │ └─┬ members + │ │ │ │ │ └─┬ static method(props) method + │ │ │ │ │ ├── static + │ │ │ │ │ ├─┬ parameters + │ │ │ │ │ │ └─┬ props + │ │ │ │ │ │ └── type: Optional + │ │ │ │ │ └── returns: boolean + │ │ │ │ ├─┬ nested_submodule + │ │ │ │ │ ├─┬ submodules + │ │ │ │ │ │ └─┬ deeplyNested + │ │ │ │ │ │ └─┬ types + │ │ │ │ │ │ └─┬ interface INamespaced + │ │ │ │ │ │ └─┬ members + │ │ │ │ │ │ └─┬ definedAt property + │ │ │ │ │ │ ├── abstract + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: string + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ class Namespaced + │ │ │ │ │ ├── interfaces: INamespaced + │ │ │ │ │ └─┬ members + │ │ │ │ │ ├─┬ definedAt property + │ │ │ │ │ │ ├── immutable + │ │ │ │ │ │ └── type: string + │ │ │ │ │ └─┬ goodness property + │ │ │ │ │ ├── abstract + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.Goodness + │ │ │ │ ├─┬ param + │ │ │ │ │ └─┬ types + │ │ │ │ │ └─┬ interface SpecialParameter + │ │ │ │ │ └─┬ members + │ │ │ │ │ └─┬ value property + │ │ │ │ │ ├── abstract + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: string + │ │ │ │ └─┬ returnsparam + │ │ │ │ └─┬ types + │ │ │ │ └─┬ class ReturnsSpecialParameter + │ │ │ │ └─┬ members + │ │ │ │ ├── () initializer + │ │ │ │ └─┬ returnsSpecialParam() method + │ │ │ │ └── returns: jsii-calc.submodule.param.SpecialParameter + │ │ │ └─┬ types + │ │ │ ├─┬ class MyClass + │ │ │ │ ├── interfaces: INamespaced + │ │ │ │ └─┬ members + │ │ │ │ ├─┬ (props) initializer + │ │ │ │ │ └─┬ parameters + │ │ │ │ │ └─┬ props + │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct + │ │ │ │ ├─┬ methodWithSpecialParam(param) method + │ │ │ │ │ ├─┬ parameters + │ │ │ │ │ │ └─┬ param + │ │ │ │ │ │ └── type: jsii-calc.submodule.param.SpecialParameter + │ │ │ │ │ └── returns: string + │ │ │ │ ├─┬ awesomeness property + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.Awesomeness + │ │ │ │ ├─┬ definedAt property + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: string + │ │ │ │ ├─┬ goodness property + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.Goodness + │ │ │ │ ├─┬ props property + │ │ │ │ │ ├── immutable + │ │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct + │ │ │ │ └─┬ allTypes property + │ │ │ │ └── type: Optional + │ │ │ └─┬ interface Default + │ │ │ └─┬ members + │ │ │ └─┬ foo property + │ │ │ ├── abstract + │ │ │ ├── immutable + │ │ │ └── type: number + │ │ └─┬ union │ │ └─┬ types - │ │ ├─┬ class MyClass - │ │ │ ├── interfaces: INamespaced + │ │ ├─┬ class ConsumesUnion + │ │ │ └─┬ members + │ │ │ └─┬ static unionType(param) method + │ │ │ ├── static + │ │ │ ├─┬ parameters + │ │ │ │ └─┬ param + │ │ │ │ └── type: jsii-calc.union.IResolvable | jsii-calc.union.Resolvable | @scope/jsii-calc-lib.IFriendly + │ │ │ └── returns: void + │ │ ├─┬ class Resolvable + │ │ │ ├── interfaces: IResolvable │ │ │ └─┬ members - │ │ │ ├─┬ (props) initializer - │ │ │ │ └─┬ parameters - │ │ │ │ └─┬ props - │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct - │ │ │ ├─┬ methodWithSpecialParam(param) method - │ │ │ │ ├─┬ parameters - │ │ │ │ │ └─┬ param - │ │ │ │ │ └── type: jsii-calc.submodule.param.SpecialParameter - │ │ │ │ └── returns: string - │ │ │ ├─┬ awesomeness property - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.Awesomeness - │ │ │ ├─┬ definedAt property - │ │ │ │ ├── immutable - │ │ │ │ └── type: string - │ │ │ ├─┬ goodness property - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.Goodness - │ │ │ ├─┬ props property - │ │ │ │ ├── immutable - │ │ │ │ └── type: jsii-calc.submodule.child.SomeStruct - │ │ │ └─┬ allTypes property - │ │ │ └── type: Optional - │ │ └─┬ interface Default + │ │ │ └─┬ resolve() method + │ │ │ └── returns: any + │ │ └─┬ interface IResolvable │ │ └─┬ members - │ │ └─┬ foo property + │ │ └─┬ resolve() method │ │ ├── abstract - │ │ ├── immutable - │ │ └── type: number + │ │ └── returns: any │ └─┬ types │ ├─┬ class AbstractClass │ │ ├── base: AbstractClassBase @@ -3703,16 +3726,17 @@ exports[`signatures 1`] = ` │ │ ├── sub1 │ │ └── sub2 │ ├── onlystatic - │ └─┬ submodule - │ └─┬ submodules - │ ├── back_references - │ ├── child - │ ├── isolated - │ ├─┬ nested_submodule - │ │ └─┬ submodules - │ │ └── deeplyNested - │ ├── param - │ └── returnsparam + │ ├─┬ submodule + │ │ └─┬ submodules + │ │ ├── back_references + │ │ ├── child + │ │ ├── isolated + │ │ ├─┬ nested_submodule + │ │ │ └─┬ submodules + │ │ │ └── deeplyNested + │ │ ├── param + │ │ └── returnsparam + │ └── union ├── @scope/jsii-calc-base ├── @scope/jsii-calc-base-of-base └─┬ @scope/jsii-calc-lib @@ -3827,40 +3851,45 @@ exports[`types 1`] = ` │ │ ├─┬ onlystatic │ │ │ └─┬ types │ │ │ └── class OnlyStaticMethods - │ │ └─┬ submodule - │ │ ├─┬ submodules - │ │ │ ├─┬ back_references - │ │ │ │ └─┬ types - │ │ │ │ └── interface MyClassReference - │ │ │ ├─┬ child - │ │ │ │ └─┬ types - │ │ │ │ ├── class InnerClass - │ │ │ │ ├── class OuterClass - │ │ │ │ ├── interface KwargsProps - │ │ │ │ ├── interface SomeStruct - │ │ │ │ ├── interface Structure - │ │ │ │ ├── enum Awesomeness - │ │ │ │ ├── enum Goodness - │ │ │ │ └── enum SomeEnum - │ │ │ ├─┬ isolated - │ │ │ │ └─┬ types - │ │ │ │ └── class Kwargs - │ │ │ ├─┬ nested_submodule - │ │ │ │ ├─┬ submodules - │ │ │ │ │ └─┬ deeplyNested - │ │ │ │ │ └─┬ types - │ │ │ │ │ └── interface INamespaced - │ │ │ │ └─┬ types - │ │ │ │ └── class Namespaced - │ │ │ ├─┬ param - │ │ │ │ └─┬ types - │ │ │ │ └── interface SpecialParameter - │ │ │ └─┬ returnsparam - │ │ │ └─┬ types - │ │ │ └── class ReturnsSpecialParameter + │ │ ├─┬ submodule + │ │ │ ├─┬ submodules + │ │ │ │ ├─┬ back_references + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── interface MyClassReference + │ │ │ │ ├─┬ child + │ │ │ │ │ └─┬ types + │ │ │ │ │ ├── class InnerClass + │ │ │ │ │ ├── class OuterClass + │ │ │ │ │ ├── interface KwargsProps + │ │ │ │ │ ├── interface SomeStruct + │ │ │ │ │ ├── interface Structure + │ │ │ │ │ ├── enum Awesomeness + │ │ │ │ │ ├── enum Goodness + │ │ │ │ │ └── enum SomeEnum + │ │ │ │ ├─┬ isolated + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── class Kwargs + │ │ │ │ ├─┬ nested_submodule + │ │ │ │ │ ├─┬ submodules + │ │ │ │ │ │ └─┬ deeplyNested + │ │ │ │ │ │ └─┬ types + │ │ │ │ │ │ └── interface INamespaced + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── class Namespaced + │ │ │ │ ├─┬ param + │ │ │ │ │ └─┬ types + │ │ │ │ │ └── interface SpecialParameter + │ │ │ │ └─┬ returnsparam + │ │ │ │ └─┬ types + │ │ │ │ └── class ReturnsSpecialParameter + │ │ │ └─┬ types + │ │ │ ├── class MyClass + │ │ │ └── interface Default + │ │ └─┬ union │ │ └─┬ types - │ │ ├── class MyClass - │ │ └── interface Default + │ │ ├── class ConsumesUnion + │ │ ├── class Resolvable + │ │ └── interface IResolvable │ └─┬ types │ ├── class AbstractClass │ ├── class AbstractClassBase diff --git a/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap b/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap index 88b91e4af3..4175895716 100644 --- a/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap +++ b/packages/jsii-reflect/test/__snapshots__/type-system.test.js.snap @@ -189,6 +189,8 @@ exports[`TypeSystem.classes lists all the classes in the typesystem 1`] = ` "jsii-calc.submodule.isolated.Kwargs", "jsii-calc.submodule.nested_submodule.Namespaced", "jsii-calc.submodule.returnsparam.ReturnsSpecialParameter", + "jsii-calc.union.ConsumesUnion", + "jsii-calc.union.Resolvable", ] `; diff --git a/tsconfig-base.json b/tsconfig-base.json index 9b3a340c0f..e8d41fbe6f 100644 --- a/tsconfig-base.json +++ b/tsconfig-base.json @@ -21,5 +21,6 @@ "composite": true, /* Ensure TypeScript can determine where to find the outputs of the referenced project to compile project. */ "incremental": true, /* Enable incremental compilation by reading/writing information from prior compilations to a file on disk. */ "useDefineForClassFields": false, /* Use Object.defineProperty for introducing class fields. */ + "skipLibCheck": true, /* Skip type checking of declaration files. */ } }