mirror of
https://github.com/wailsapp/wails.git
synced 2025-05-04 23:23:48 +08:00
392 lines
9.9 KiB
Go
392 lines
9.9 KiB
Go
package render
|
|
|
|
import (
|
|
"fmt"
|
|
"go/types"
|
|
"strings"
|
|
"text/template"
|
|
|
|
"github.com/wailsapp/wails/v3/internal/generator/collect"
|
|
"golang.org/x/tools/go/types/typeutil"
|
|
)
|
|
|
|
// SkipCreate returns true if the given array of types needs no creation code.
|
|
func (m *module) SkipCreate(ts []types.Type) bool {
|
|
for _, typ := range ts {
|
|
if m.NeedsCreate(typ) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// NeedsCreate returns true if the given type needs some creation code.
|
|
func (m *module) NeedsCreate(typ types.Type) bool {
|
|
return m.needsCreateImpl(typ, new(typeutil.Map))
|
|
}
|
|
|
|
// needsCreateImpl provides the actual implementation of NeedsCreate.
|
|
// The visited parameter is used to break cycles.
|
|
func (m *module) needsCreateImpl(typ types.Type, visited *typeutil.Map) bool {
|
|
switch t := typ.(type) {
|
|
case *types.Alias:
|
|
return m.needsCreateImpl(types.Unalias(typ), visited)
|
|
|
|
case *types.Named:
|
|
if visited.Set(typ, true) != nil {
|
|
// The only way to hit a cycle here
|
|
// is through a chain of structs, nested pointers and arrays (not slices).
|
|
// We can safely return false at this point
|
|
// as the final answer is independent of the cycle.
|
|
return false
|
|
}
|
|
|
|
if t.Obj().Pkg() == nil {
|
|
// Builtin named type: render underlying type.
|
|
return m.needsCreateImpl(t.Underlying(), visited)
|
|
}
|
|
|
|
if collect.IsAny(typ) || collect.IsStringAlias(typ) {
|
|
break
|
|
} else if collect.IsClass(typ) {
|
|
return true
|
|
} else {
|
|
return m.needsCreateImpl(t.Underlying(), visited)
|
|
}
|
|
|
|
case *types.Array, *types.Pointer:
|
|
return m.needsCreateImpl(typ.(interface{ Elem() types.Type }).Elem(), visited)
|
|
|
|
case *types.Map, *types.Slice:
|
|
return true
|
|
|
|
case *types.Struct:
|
|
if t.NumFields() == 0 || collect.MaybeJSONMarshaler(typ) != collect.NonMarshaler || collect.MaybeTextMarshaler(typ) != collect.NonMarshaler {
|
|
return false
|
|
}
|
|
|
|
info := m.collector.Struct(t)
|
|
info.Collect()
|
|
|
|
for _, field := range info.Fields {
|
|
if m.needsCreateImpl(field.Type, visited) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
case *types.TypeParam:
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// JSCreate renders JS/TS code that creates an instance
|
|
// of the given type from JSON data.
|
|
//
|
|
// JSCreate's output may be incorrect
|
|
// if m.Imports.AddType has not been called for the given type.
|
|
func (m *module) JSCreate(typ types.Type) string {
|
|
return m.JSCreateWithParams(typ, "")
|
|
}
|
|
|
|
// JSCreateWithParams renders JS/TS code that creates an instance
|
|
// of the given type from JSON data. For generic types,
|
|
// it renders parameterised code.
|
|
//
|
|
// JSCreateWithParams's output may be incorrect
|
|
// if m.Imports.AddType has not been called for the given type.
|
|
func (m *module) JSCreateWithParams(typ types.Type, params string) string {
|
|
if len(params) > 0 && !m.hasTypeParams(typ) {
|
|
// Forget params for non-generic types.
|
|
params = ""
|
|
}
|
|
|
|
switch t := typ.(type) {
|
|
case *types.Alias:
|
|
return m.JSCreateWithParams(types.Unalias(typ), params)
|
|
|
|
case *types.Array, *types.Pointer:
|
|
pp, ok := m.postponedCreates.At(typ).(*postponed)
|
|
if ok {
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
}
|
|
|
|
createElement := m.JSCreateWithParams(typ.(interface{ Elem() types.Type }).Elem(), params)
|
|
if createElement != "$Create.Any" {
|
|
pp = &postponed{m.postponedCreates.Len(), params}
|
|
m.postponedCreates.Set(typ, pp)
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
}
|
|
|
|
case *types.Map:
|
|
pp, ok := m.postponedCreates.At(typ).(*postponed)
|
|
if !ok {
|
|
m.JSCreateWithParams(t.Elem(), params)
|
|
pp = &postponed{m.postponedCreates.Len(), params}
|
|
m.postponedCreates.Set(typ, pp)
|
|
}
|
|
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
|
|
case *types.Named:
|
|
if t.Obj().Pkg() == nil {
|
|
// Builtin named type: render underlying type.
|
|
return m.JSCreateWithParams(t.Underlying(), params)
|
|
}
|
|
|
|
if !m.NeedsCreate(typ) {
|
|
break
|
|
}
|
|
|
|
pp, ok := m.postponedCreates.At(typ).(*postponed)
|
|
if !ok {
|
|
if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
|
|
// Postpone type args.
|
|
for i := range t.TypeArgs().Len() {
|
|
m.JSCreateWithParams(t.TypeArgs().At(i), params)
|
|
}
|
|
}
|
|
|
|
pp = &postponed{m.postponedCreates.Len(), params}
|
|
m.postponedCreates.Set(typ, pp)
|
|
|
|
if !collect.IsClass(typ) {
|
|
m.JSCreateWithParams(t.Underlying(), params)
|
|
}
|
|
}
|
|
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
|
|
case *types.Slice:
|
|
if types.Identical(typ, typeByteSlice) {
|
|
return "$Create.ByteSlice"
|
|
}
|
|
|
|
pp, ok := m.postponedCreates.At(typ).(*postponed)
|
|
if !ok {
|
|
m.JSCreateWithParams(t.Elem(), params)
|
|
pp = &postponed{m.postponedCreates.Len(), params}
|
|
m.postponedCreates.Set(typ, pp)
|
|
}
|
|
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
|
|
case *types.Struct:
|
|
if t.NumFields() == 0 || collect.MaybeJSONMarshaler(typ) != collect.NonMarshaler || collect.MaybeTextMarshaler(typ) != collect.NonMarshaler {
|
|
break
|
|
}
|
|
|
|
pp, ok := m.postponedCreates.At(typ).(*postponed)
|
|
if ok {
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
}
|
|
|
|
info := m.collector.Struct(t)
|
|
info.Collect()
|
|
|
|
postpone := false
|
|
for _, field := range info.Fields {
|
|
if m.JSCreateWithParams(field.Type, params) != "$Create.Any" {
|
|
postpone = true
|
|
}
|
|
}
|
|
|
|
if postpone {
|
|
pp = &postponed{m.postponedCreates.Len(), params}
|
|
m.postponedCreates.Set(typ, pp)
|
|
return fmt.Sprintf("$$createType%d%s", pp.index, params)
|
|
}
|
|
|
|
case *types.TypeParam:
|
|
return fmt.Sprintf("$$createParam%s", typeparam(t.Index(), t.Obj().Name()))
|
|
}
|
|
|
|
return "$Create.Any"
|
|
}
|
|
|
|
// PostponedCreates returns the list of postponed create functions
|
|
// for the given module.
|
|
func (m *module) PostponedCreates() []string {
|
|
result := make([]string, m.postponedCreates.Len())
|
|
|
|
m.postponedCreates.Iterate(func(key types.Type, value any) {
|
|
pp := value.(*postponed)
|
|
|
|
pre, post := "", ""
|
|
if pp.params != "" {
|
|
if m.TS {
|
|
pre = createParamRegex.ReplaceAllString(pp.params, "${0}: any") + " => "
|
|
} else {
|
|
pre = "/** @type {(...args: any[]) => any} */(" + pp.params + " => "
|
|
post = ")"
|
|
}
|
|
}
|
|
|
|
switch t := key.(type) {
|
|
case *types.Array, *types.Slice:
|
|
result[pp.index] = fmt.Sprintf("%s$Create.Array(%s)%s", pre, m.JSCreateWithParams(t.(interface{ Elem() types.Type }).Elem(), pp.params), post)
|
|
|
|
case *types.Map:
|
|
result[pp.index] = fmt.Sprintf("%s$Create.Map($Create.Any, %s)%s", pre, m.JSCreateWithParams(t.Elem(), pp.params), post)
|
|
|
|
case *types.Named:
|
|
if !collect.IsClass(key) {
|
|
// Creation functions for non-struct named types
|
|
// require an indirect assignment to break cycles.
|
|
|
|
// Typescript cannot infer the return type on its own: add hints.
|
|
cast, argType, returnType := "", "", ""
|
|
if m.TS {
|
|
argType = ": any[]"
|
|
returnType = ": any"
|
|
} else {
|
|
cast = "/** @type {(...args: any[]) => any} */"
|
|
}
|
|
|
|
result[pp.index] = fmt.Sprintf(`
|
|
%s(function $$initCreateType%d(...args%s)%s {
|
|
if ($$createType%d === $$initCreateType%d) {
|
|
$$createType%d = %s%s%s;
|
|
}
|
|
return $$createType%d(...args);
|
|
})`,
|
|
cast, pp.index, argType, returnType,
|
|
pp.index, pp.index,
|
|
pp.index, pre, m.JSCreateWithParams(t.Underlying(), pp.params), post,
|
|
pp.index,
|
|
)[1:] // Remove initial newline.
|
|
|
|
// We're done.
|
|
break
|
|
}
|
|
|
|
var builder strings.Builder
|
|
|
|
builder.WriteString(pre)
|
|
|
|
if t.Obj().Pkg().Path() == m.Imports.Self {
|
|
if m.Imports.ImportModels {
|
|
builder.WriteString("$models.")
|
|
}
|
|
} else {
|
|
builder.WriteString(jsimport(m.Imports.External[t.Obj().Pkg().Path()]))
|
|
builder.WriteRune('.')
|
|
}
|
|
builder.WriteString(jsid(t.Obj().Name()))
|
|
builder.WriteString(".createFrom")
|
|
|
|
if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
|
|
builder.WriteString("(")
|
|
for i := range t.TypeArgs().Len() {
|
|
if i > 0 {
|
|
builder.WriteString(", ")
|
|
}
|
|
builder.WriteString(m.JSCreateWithParams(t.TypeArgs().At(i), pp.params))
|
|
}
|
|
builder.WriteString(")")
|
|
}
|
|
builder.WriteString(post)
|
|
|
|
result[pp.index] = builder.String()
|
|
|
|
case *types.Pointer:
|
|
result[pp.index] = fmt.Sprintf("%s$Create.Nullable(%s)%s", pre, m.JSCreateWithParams(t.Elem(), pp.params), post)
|
|
|
|
case *types.Struct:
|
|
info := m.collector.Struct(t)
|
|
info.Collect()
|
|
|
|
var builder strings.Builder
|
|
builder.WriteString(pre)
|
|
builder.WriteString("$Create.Struct({")
|
|
|
|
for _, field := range info.Fields {
|
|
createField := m.JSCreateWithParams(field.Type, pp.params)
|
|
if createField == "$Create.Any" {
|
|
continue
|
|
}
|
|
|
|
builder.WriteString("\n \"")
|
|
template.JSEscape(&builder, []byte(field.JsonName))
|
|
builder.WriteString("\": ")
|
|
builder.WriteString(createField)
|
|
builder.WriteRune(',')
|
|
}
|
|
|
|
if len(info.Fields) > 0 {
|
|
builder.WriteRune('\n')
|
|
}
|
|
builder.WriteString("})")
|
|
builder.WriteString(post)
|
|
|
|
result[pp.index] = builder.String()
|
|
|
|
default:
|
|
result[pp.index] = pre + "$Create.Any" + post
|
|
}
|
|
})
|
|
|
|
if Newline != "\n" {
|
|
// Replace newlines according to local git config.
|
|
for i := range result {
|
|
result[i] = strings.ReplaceAll(result[i], "\n", Newline)
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
type postponed struct {
|
|
index int
|
|
params string
|
|
}
|
|
|
|
// hasTypeParams returns true if the given type depends upon type parameters.
|
|
func (m *module) hasTypeParams(typ types.Type) bool {
|
|
switch t := typ.(type) {
|
|
case *types.Alias:
|
|
if t.Obj().Pkg() == nil {
|
|
// Builtin alias: these are never rendered as templates.
|
|
return false
|
|
}
|
|
|
|
return m.hasTypeParams(types.Unalias(typ))
|
|
|
|
case *types.Array, *types.Pointer, *types.Slice:
|
|
return m.hasTypeParams(typ.(interface{ Elem() types.Type }).Elem())
|
|
|
|
case *types.Map:
|
|
return m.hasTypeParams(t.Key()) || m.hasTypeParams(t.Elem())
|
|
|
|
case *types.Named:
|
|
if t.Obj().Pkg() == nil {
|
|
// Builtin named type: these are never rendered as templates.
|
|
return false
|
|
}
|
|
|
|
if targs := t.TypeArgs(); targs != nil {
|
|
for i := range targs.Len() {
|
|
if m.hasTypeParams(targs.At(i)) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
case *types.Struct:
|
|
info := m.collector.Struct(t)
|
|
info.Collect()
|
|
|
|
for _, field := range info.Fields {
|
|
if m.hasTypeParams(field.Type) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
case *types.TypeParam:
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|