blob: 627d57cd3af15f7a5e56bd60ae3162da42c8679e [file] [log] [blame]
// Copyright 2020 CUE Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package export
import (
"fmt"
"sort"
"cuelang.org/go/cue/ast"
"cuelang.org/go/cue/token"
"cuelang.org/go/internal/core/adt"
)
// Modes:
// raw: as is
// def: merge structs, print reset as is.
//
// Possible simplifications in def mode:
// - merge contents of multiple _literal_ structs.
// - this is not possible if some of the elements are bulk optional
// (or is it?).
// - still do not ever resolve references.
// - to do this, fields must be pre-linked to their destinations.
// - use astutil.Sanitize to resolve shadowing and imports.
//
//
// Categories of printing:
// - concrete
// - optionals
// - references
// - constraints
//
// Mixed mode is also not supported in the old implementation (at least not
// correctly). It requires references to resolve properly, backtracking to
// a common root and prefixing that to the reference. This is now possible
// with the Environment construct and could be done later.
func (e *exporter) expr(v adt.Expr) (result ast.Expr) {
switch x := v.(type) {
case nil:
return nil
case *adt.Vertex:
if len(x.Conjuncts) == 0 || x.IsData() {
// Treat as literal value.
return e.value(x)
} // Should this be the arcs label?
a := []conjunct{}
for _, c := range x.Conjuncts {
a = append(a, conjunct{c, 0})
}
return e.mergeValues(adt.InvalidLabel, x, a, x.Conjuncts...)
case *adt.StructLit:
c := adt.MakeRootConjunct(nil, x)
return e.mergeValues(adt.InvalidLabel, nil, []conjunct{{c: c, up: 0}}, c)
case adt.Value:
return e.value(x) // Use conjuncts.
default:
return e.adt(v, nil)
}
}
// Piece out values:
// For a struct, piece out conjuncts that are already values. Those can be
// unified. All other conjuncts are added verbatim.
func (x *exporter) mergeValues(label adt.Feature, src *adt.Vertex, a []conjunct, orig ...adt.Conjunct) ast.Expr {
e := conjuncts{
exporter: x,
values: &adt.Vertex{},
fields: map[adt.Feature]field{},
attrs: []*ast.Attribute{},
}
_, saved := e.pushFrame(orig)
defer e.popFrame(saved)
for _, c := range a {
e.top().upCount = c.up
x := c.c.Expr()
e.addExpr(c.c.Env, src, x, false)
}
if src != nil {
for _, a := range src.Arcs {
if x, ok := e.fields[a.Label]; ok {
x.arc = a
e.fields[a.Label] = x
}
}
}
s := x.top().scope
for _, a := range e.attrs {
s.Elts = append(s.Elts, a)
}
// Unify values only for one level.
if a := e.values.Conjuncts; len(a) > 0 {
e.values.Finalize(e.ctx)
e.embed = append(e.embed, e.value(e.values, a...))
}
// Collect and order set of fields.
fields := []adt.Feature{}
for f := range e.fields {
fields = append(fields, f)
}
// Sort fields in case features lists are missing to ensure
// predictability. Also sort in reverse order, so that bugs
// are more likely exposed.
sort.Slice(fields, func(i, j int) bool {
return fields[i] > fields[j]
})
m := sortArcs(extractFeatures(e.structs))
sort.SliceStable(fields, func(i, j int) bool {
if m[fields[j]] == 0 {
return m[fields[i]] != 0
}
return m[fields[i]] > m[fields[j]]
})
if len(e.fields) == 0 && !e.hasEllipsis {
switch len(e.embed) + len(e.conjuncts) {
case 0:
if len(e.attrs) > 0 {
break
}
if len(e.structs) > 0 {
return s
}
return ast.NewIdent("_")
case 1:
var x ast.Expr
if len(e.conjuncts) == 1 {
x = e.conjuncts[0]
} else {
x = e.embed[0]
}
if len(e.attrs) == 0 {
return x
}
if st, ok := x.(*ast.StructLit); ok {
s.Elts = append(s.Elts, st.Elts...)
return s
}
case 2:
if len(e.attrs) > 0 {
break
}
// Simplify.
e.conjuncts = append(e.conjuncts, e.embed...)
return ast.NewBinExpr(token.AND, e.conjuncts...)
}
}
for _, x := range e.embed {
s.Elts = append(s.Elts, &ast.EmbedDecl{Expr: x})
}
for _, f := range fields {
field := e.fields[f]
c := field.conjuncts
label := e.stringLabel(f)
if f.IsDef() {
x.inDefinition++
}
a := []adt.Conjunct{}
for _, cc := range c {
a = append(a, cc.c)
}
d := &ast.Field{Label: label}
top := e.frame(0)
if fr, ok := top.fields[f]; ok && fr.alias != "" {
setFieldAlias(d, fr.alias)
fr.node = d
top.fields[f] = fr
}
d.Value = e.mergeValues(f, field.arc, c, a...)
if f.IsDef() {
x.inDefinition--
}
if isOptional(a) {
d.Optional = token.Blank.Pos()
}
if x.cfg.ShowDocs {
docs := extractDocs(src, a)
ast.SetComments(d, docs)
}
if x.cfg.ShowAttributes {
for _, c := range a {
d.Attrs = extractFieldAttrs(d.Attrs, c)
}
}
s.Elts = append(s.Elts, d)
}
if e.hasEllipsis {
s.Elts = append(s.Elts, &ast.Ellipsis{})
}
// TODO: why was this necessary?
// else if src != nil && src.IsClosedStruct() && e.inDefinition == 0 {
// return ast.NewCall(ast.NewIdent("close"), s)
// }
e.conjuncts = append(e.conjuncts, s)
return ast.NewBinExpr(token.AND, e.conjuncts...)
}
// Conjuncts if for collecting values of a single vertex.
type conjuncts struct {
*exporter
// Values is used to collect non-struct values.
values *adt.Vertex
embed []ast.Expr
conjuncts []ast.Expr
structs []*adt.StructInfo
fields map[adt.Feature]field
attrs []*ast.Attribute
hasEllipsis bool
}
func (c *conjuncts) addValueConjunct(src *adt.Vertex, env *adt.Environment, x adt.Expr) {
switch b, ok := x.(adt.BaseValue); {
case ok && src != nil && isTop(b) && !isTop(src.BaseValue):
// drop top
default:
c.values.AddConjunct(adt.MakeRootConjunct(env, x))
}
}
func (c *conjuncts) addConjunct(f adt.Feature, env *adt.Environment, n adt.Node) {
x := c.fields[f]
v := adt.MakeRootConjunct(env, n)
x.conjuncts = append(x.conjuncts, conjunct{
c: v,
up: c.top().upCount,
})
// x.upCounts = append(x.upCounts, c.top().upCount)
c.fields[f] = x
}
type field struct {
docs []*ast.CommentGroup
arc *adt.Vertex
conjuncts []conjunct
}
type conjunct struct {
c adt.Conjunct
up int32
}
func (e *conjuncts) addExpr(env *adt.Environment, src *adt.Vertex, x adt.Expr, isEmbed bool) {
switch x := x.(type) {
case *adt.StructLit:
e.top().upCount++
if e.cfg.ShowAttributes {
e.attrs = extractDeclAttrs(e.attrs, x.Src)
}
// Only add if it only has no bulk fields or elipsis.
if isComplexStruct(x) {
_, saved := e.pushFrame(nil)
e.embed = append(e.embed, e.adt(x, nil))
e.top().upCount-- // not necessary, but for proper form
e.popFrame(saved)
return
}
// Used for sorting.
e.structs = append(e.structs, &adt.StructInfo{StructLit: x, Env: env})
for _, d := range x.Decls {
var label adt.Feature
switch f := d.(type) {
case *adt.Field:
label = f.Label
case *adt.OptionalField:
// TODO: mark optional here.
label = f.Label
case *adt.Ellipsis:
e.hasEllipsis = true
continue
case adt.Expr:
e.addExpr(env, nil, f, true)
continue
// TODO: also handle dynamic fields
default:
panic(fmt.Sprintf("Unexpected type %T", d))
}
e.addConjunct(label, env, d)
}
e.top().upCount--
case adt.Value: // other values.
switch v := x.(type) {
case nil:
default:
e.addValueConjunct(src, env, x)
case *adt.Vertex:
if b, ok := v.BaseValue.(*adt.Bottom); ok {
if !b.IsIncomplete() || e.cfg.Final {
e.addExpr(env, v, b, false)
return
}
}
switch {
default:
for _, c := range v.Conjuncts {
e.addExpr(c.Env, v, c.Expr(), false)
}
case v.IsData():
e.structs = append(e.structs, v.Structs...)
if y, ok := v.BaseValue.(adt.Value); ok {
e.addValueConjunct(src, env, y)
}
for _, a := range v.Arcs {
a.Finalize(e.ctx) // TODO: should we do this?
e.addConjunct(a.Label, env, a)
}
}
}
case *adt.BinaryExpr:
switch {
case x.Op == adt.AndOp && !isEmbed:
e.addExpr(env, src, x.X, false)
e.addExpr(env, src, x.Y, false)
case isSelfContained(x):
e.addValueConjunct(src, env, x)
default:
if isEmbed {
e.embed = append(e.embed, e.expr(x))
} else {
e.conjuncts = append(e.conjuncts, e.expr(x))
}
}
default:
switch {
case isSelfContained(x):
e.addValueConjunct(src, env, x)
case isEmbed:
e.embed = append(e.embed, e.expr(x))
default:
e.conjuncts = append(e.conjuncts, e.expr(x))
}
}
}
func isTop(x adt.BaseValue) bool {
switch v := x.(type) {
case *adt.Top:
return true
case *adt.BasicType:
return v.K == adt.TopKind
default:
return false
}
}
// TODO: find a better way to annotate optionality. Maybe a special conjunct
// or store it in the field information?
func isOptional(a []adt.Conjunct) bool {
if len(a) == 0 {
return false
}
for _, c := range a {
if v, ok := c.Expr().(*adt.Vertex); ok && !v.IsData() && len(v.Conjuncts) > 0 {
return isOptional(v.Conjuncts)
}
switch f := c.Source().(type) {
case nil:
return false
case *ast.Field:
if f.Optional == token.NoPos {
return false
}
}
}
return true
}
func isComplexStruct(s *adt.StructLit) bool {
for _, d := range s.Decls {
switch x := d.(type) {
case *adt.Field:
// TODO: remove this and also handle field annotation in expr().
// This allows structs to be merged. Ditto below.
if x.Src != nil {
if _, ok := x.Src.Label.(*ast.Alias); ok {
return ok
}
}
case *adt.OptionalField:
if x.Src != nil {
if _, ok := x.Src.Label.(*ast.Alias); ok {
return ok
}
}
case adt.Expr:
case *adt.Ellipsis:
if x.Value != nil {
return true
}
default:
return true
}
}
return false
}
func isSelfContained(expr adt.Expr) bool {
switch x := expr.(type) {
case *adt.BinaryExpr:
return isSelfContained(x.X) && isSelfContained(x.Y)
case *adt.UnaryExpr:
return isSelfContained(x.X)
case *adt.BoundExpr:
return isSelfContained(x.Expr)
case adt.Value:
return true
}
return false
}