Add weakly typed enums aka alias constants

Author: fbbdev

docs/src/content/docs/changelog.mdx

@@ -50,6 +50,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Add binding generator support for `omitzero` JSON flag by [@fbbdev](https://github.com/fbbdev) in [#4045](https://github.com/wailsapp/wails/pull/4045)
 - Add `//wails:ignore` directive to prevent binding generation for chosen service methods by [@fbbdev](https://github.com/fbbdev) in [#4045](https://github.com/wailsapp/wails/pull/4045)
 - Add `//wails:internal` directive on services and models to allow for types that are exported in Go but not in JS/TS by [@fbbdev](https://github.com/fbbdev) in [#4045](https://github.com/wailsapp/wails/pull/4045)
+- Add binding generator support for constants of alias type to allow for weakly typed enums by [@fbbdev](https://github.com/fbbdev) in [#4045](https://github.com/wailsapp/wails/pull/4045)
 
 ### Fixed
 

v3/internal/generator/collect/model.go

@@ -192,6 +192,24 @@ func (info *ModelInfo) Collect() *ModelInfo {
 			// because in doing so we could end up with a private type from another package.
 			def = t.Rhs()
 
+			// Test for constants with alias type,
+			// but only when non-generic alias resolves to a basic type
+			// (hence not to e.g. a named type).
+			if basic, ok := types.Unalias(def).(*types.Basic); ok {
+				if !isGeneric && basic.Info()&types.IsConstType != 0 && basic.Info()&types.IsComplex == 0 {
+					// Non-generic alias resolves to a representable constant type:
+					// look for defined constants whose type is exactly the alias typ.
+					for _, name := range obj.Pkg().Scope().Names() {
+						if cnst, ok := obj.Pkg().Scope().Lookup(name).(*types.Const); ok {
+							alias, isAlias := cnst.Type().(*types.Alias)
+							if isAlias && cnst.Val().Kind() != constant.Unknown && alias.Obj() == t.Obj() {
+								constants = append(constants, cnst)
+							}
+						}
+					}
+				}
+			}
+
 		case *types.Named:
 			// Model is a named type:
 			// jump directly to underlying type to match go semantics,
@@ -222,7 +240,7 @@ func (info *ModelInfo) Collect() *ModelInfo {
 					info.Type = types.Typ[types.String]
 					return
 				}
-			} else if basic, ok := def.(*types.Basic); ok {
+			} else if basic, ok := def.Underlying().(*types.Basic); ok {
 				// Test for enums (excluding marshalers and generic types).
 				if !isGeneric && basic.Info()&types.IsConstType != 0 && basic.Info()&types.IsComplex == 0 {
 					// Named type is defined as a representable constant type:
@@ -255,12 +273,10 @@ func (info *ModelInfo) Collect() *ModelInfo {
 		info.Imports.AddType(def)
 
 		// Handle enum types.
-		// constants slice is always empty for aliases, structs, marshalers.
+		// constants slice is always empty for structs, marshalers.
 		if len(constants) > 0 {
 			// Collect information about enum values.
 			info.collectEnum(constants)
-			info.Type = def
-			return
 		}
 
 		// That's all, folks. Render as a TS alias.

v3/internal/generator/render/info.go

@@ -8,7 +8,8 @@ import (
 
 // modelInfo gathers useful information about a model.
 type modelInfo struct {
-	IsEnum bool
+	HasValues bool
+	IsEnum    bool
 
 	IsAlias      bool
 	IsClassAlias bool
@@ -27,7 +28,8 @@ type modelInfo struct {
 
 // modelinfo gathers and returns useful information about the given model.
 func modelinfo(model *collect.ModelInfo, useInterfaces bool) (info modelInfo) {
-	info.IsEnum = len(model.Values) > 0
+	info.HasValues = len(model.Values) > 0
+	info.IsEnum = info.HasValues && !model.Alias
 
 	info.IsAlias = !info.IsEnum && model.Type != nil
 	info.IsClassAlias = info.IsAlias && model.Predicates.IsClass && !useInterfaces

v3/internal/generator/render/templates/index.tmpl

@@ -39,7 +39,7 @@ export {
 
 {{- $info := modelinfo $model $useInterfaces }}
 
-{{- if or $info.IsEnum $info.IsClassAlias $info.IsClass}}
+{{- if or $info.HasValues $info.IsClassAlias $info.IsClass}}
 {{- if not $hasObjects}}
     {{- $hasObjects = true}}
 export {
@@ -67,7 +67,7 @@ import * as $models from "./{{js $models}}";
 {{- $info := modelinfo $model $useInterfaces }}
 {{- $template := $info.Template }}
 
-{{- if or $info.IsEnum $info.IsClassAlias $info.IsClass}}{{continue}}{{end}}
+{{- if or $info.HasValues $info.IsClassAlias $info.IsClass}}{{continue}}{{end}}
 
 {{- if $renderer.TS}}
     {{- if $hasTypes}},{{end}}

v3/internal/generator/render/templates/models.js.tmpl

@@ -57,13 +57,22 @@ import * as {{jsimport .}} from "{{js .RelPath}}/{{js $models}}";
 {{- end}}
  */
 {{- end}}
-{{- if $info.IsEnum}}
+{{- if $info.HasValues}}
+{{- if not $info.IsEnum}}
+
+/**
+ * Predefined constants for type {{jsid $model.Name}}.
+ * @namespace
+ */
+{{- end}}
 export const {{jsid $model.Name}} = {
+{{- if $info.IsEnum}}
     /**
      * The Go zero value for the underlying type of the enum.
      */
     $zero: {{$module.JSDefault $model.Type false}},
-{{range $i, $decl := $model.Values}}{{range $j, $spec := $decl}}{{range $k, $value := $spec}}
+{{end}}
+{{- range $i, $decl := $model.Values}}{{range $j, $spec := $decl}}{{range $k, $value := $spec}}
     {{- if and (ne $i 0) (eq $j 0) (eq $k 0)}}
 {{end}}
     {{- if or (and (eq $j 0) (eq $k 0) (hasdoc $value.Decl.Doc)) (and (eq $k 0) (hasdoc $value.Spec.Doc))}}

v3/internal/generator/render/templates/models.ts.tmpl

@@ -78,6 +78,33 @@ export const {{jsid $model.Name}} = {{if istpalias $model.Type -}}
 export type {{jsid $model.Name}}{{$template.ParamList}} = {{$module.JSType $model.Type}};
 {{else if $info.IsTypeAlias}}
 export type {{jsid $model.Name}}{{$template.ParamList}} = {{$module.JSType $model.Type}};
+{{- if $info.HasValues}}
+
+/**
+ * Predefined constants for type {{jsid $model.Name}}.
+ * @namespace
+ */
+export const {{jsid $model.Name}} = {
+{{- range $i, $decl := $model.Values}}{{range $j, $spec := $decl}}{{range $k, $value := $spec}}
+    {{- if and (ne $i 0) (eq $j 0) (eq $k 0)}}
+{{end}}
+    {{- if or (and (eq $j 0) (eq $k 0) (hasdoc $value.Decl.Doc)) (and (eq $k 0) (hasdoc $value.Spec.Doc))}}
+    {{- if gt $j 0}}
+{{end}}
+    /**
+    {{- if and (eq $j 0) (eq $k 0) (hasdoc $value.Decl.Doc)}}
+    {{- jsdoc $value.Decl.Doc.Text "    "}}{{if and (eq $k 0) (hasdoc $value.Spec.Doc)}}
+     *{{end}}
+    {{- end}}
+    {{- if and (eq $k 0) (hasdoc $value.Spec.Doc)}}
+    {{- jsdoc $value.Spec.Doc.Text "    "}}
+    {{- end}}
+     */
+    {{- end}}
+    {{jsid $value.Name}}: {{jsvalue $value.Value}},
+{{- end}}{{end}}{{end}}
+};
+{{- end}}
 {{else if $info.IsClassOrInterface}}
 export {{if $info.IsInterface}}interface{{else}}class{{end}} {{jsid $model.Name}}{{$template.ParamList}} {
     {{- range $i, $decl := $model.Fields}}{{range $j, $field := $decl}}

v3/internal/generator/testcases/enum/main.go

@@ -19,6 +19,19 @@ const (
 	Dr     Title = "Dr"
 )
 
+// Age is an integer with some predefined values
+type Age = int
+
+const (
+	NewBorn    Age = 0
+	Teenager   Age = 12
+	YoungAdult Age = 18
+
+	// Oh no, some grey hair!
+	MiddleAged Age = 50
+	Mathusalem Age = 1000 // Unbelievable!
+)
+
 // GreetService is great
 type GreetService struct {
 	SomeVariable int
@@ -30,6 +43,7 @@ type GreetService struct {
 type Person struct {
 	Title Title
 	Name  string
+	Age   Age
 }
 
 // Greet does XYZ