decoder: Add support for LiteralType as Constraint

decoder/expr_literal_type.go

@@ -1,40 +1,13 @@
 package decoder
 
 import (
- "context"
-
- "github.com/hashicorp/hcl-lang/lang"
- "github.com/hashicorp/hcl-lang/reference"
  "github.com/hashicorp/hcl-lang/schema"
  "github.com/hashicorp/hcl/v2"
 )
 
 type LiteralType struct {
  expr hcl.Expression
  cons schema.LiteralType
-}
-
-func (lt LiteralType) CompletionAtPos(ctx context.Context, pos hcl.Pos) []lang.Candidate {
- // TODO
- return nil
-}
-
-func (lt LiteralType) HoverAtPos(ctx context.Context, pos hcl.Pos) *lang.HoverData {
- // TODO
- return nil
-}
-
-func (lt LiteralType) SemanticTokens(ctx context.Context) []lang.SemanticToken {
- // TODO
- return nil
-}
-
-func (lt LiteralType) ReferenceOrigins(ctx context.Context, allowSelfRefs bool) reference.Origins {
- // TODO
- return nil
-}
 
-func (lt LiteralType) ReferenceTargets(ctx context.Context, targetCtx *TargetContext) reference.Targets {
- // TODO
- return nil
+ pathCtx *PathContext
 }

decoder/expr_literal_type_completion.go

@@ -0,0 +1,204 @@
+package decoder
+
+import (
+ "context"
+ "strings"
+
+ "github.com/hashicorp/hcl-lang/lang"
+ "github.com/hashicorp/hcl-lang/schema"
+ "github.com/hashicorp/hcl/v2"
+ "github.com/hashicorp/hcl/v2/hclsyntax"
+ "github.com/zclconf/go-cty/cty"
+)
+
+func (lt LiteralType) CompletionAtPos(ctx context.Context, pos hcl.Pos) []lang.Candidate {
+ typ := lt.cons.Type
+
+ if isEmptyExpression(lt.expr) {
+ editRange := hcl.Range{
+ Filename: lt.expr.Range().Filename,
+ Start: pos,
+ End: pos,
+ }
+
+ if typ.IsPrimitiveType() {
+ if typ == cty.Bool {
+ return boolLiteralCandidates("", editRange)
+ }
+ return []lang.Candidate{}
+ }
+
+ if typ == cty.DynamicPseudoType {
+ return []lang.Candidate{}
+ }
+
+ return []lang.Candidate{
+ {
+ Label: labelForLiteralType(typ),
+ Detail: typ.FriendlyName(),
+ Kind: candidateKindForType(typ),
+ TextEdit: lang.TextEdit{
+ Range: editRange,
+ NewText: newTextForLiteralType(typ),
+ Snippet: snippetForLiteralType(1, typ),
+ },
+ },
+ }
+ }
+
+ if typ == cty.Bool {
+ return lt.completeBoolAtPos(ctx, pos)
+ }
+
+ if typ.IsListType() {
+ expr, ok := lt.expr.(*hclsyntax.TupleConsExpr)
+ if !ok {
+ return []lang.Candidate{}
+ }
+
+ cons := schema.List{
+ Elem: schema.LiteralType{
+ Type: typ.ElementType(),
+ },
+ }
+
+ return newExpression(lt.pathCtx, expr, cons).CompletionAtPos(ctx, pos)
+ }
+
+ if typ.IsSetType() {
+ expr, ok := lt.expr.(*hclsyntax.TupleConsExpr)
+ if !ok {
+ return []lang.Candidate{}
+ }
+
+ cons := schema.Set{
+ Elem: schema.LiteralType{
+ Type: typ.ElementType(),
+ },
+ }
+
+ return newExpression(lt.pathCtx, expr, cons).CompletionAtPos(ctx, pos)
+ }
+
+ if typ.IsTupleType() {
+ expr, ok := lt.expr.(*hclsyntax.TupleConsExpr)
+ if !ok {
+ return []lang.Candidate{}
+ }
+
+ elemTypes := typ.TupleElementTypes()
+ cons := schema.Tuple{
+ Elems: make([]schema.Constraint, len(elemTypes)),
+ }
+ for i, elemType := range elemTypes {
+ cons.Elems[i] = schema.LiteralType{
+ Type: elemType,
+ }
+ }
+
+ return newExpression(lt.pathCtx, expr, cons).CompletionAtPos(ctx, pos)
+ }
+
+ if typ.IsMapType() {
+ expr, ok := lt.expr.(*hclsyntax.ObjectConsExpr)
+ if !ok {
+ return []lang.Candidate{}
+ }
+
+ cons := schema.Map{
+ Elem: schema.LiteralType{
+ Type: typ.ElementType(),
+ },
+ }
+ return newExpression(lt.pathCtx, expr, cons).CompletionAtPos(ctx, pos)
+ }
+
+ if typ.IsObjectType() {
+ expr, ok := lt.expr.(*hclsyntax.ObjectConsExpr)
+ if !ok {
+ return []lang.Candidate{}
+ }
+
+ cons := schema.Object{
+ Attributes: ctyObjectToObjectAttributes(typ),
+ }
+ return newExpression(lt.pathCtx, expr, cons).CompletionAtPos(ctx, pos)
+ }
+
+ return []lang.Candidate{}
+}
+
+func (lt LiteralType) completeBoolAtPos(ctx context.Context, pos hcl.Pos) []lang.Candidate {
+ switch eType := lt.expr.(type) {
+
+ case *hclsyntax.ScopeTraversalExpr:
+ prefixLen := pos.Byte - eType.Range().Start.Byte
+ prefix := eType.Traversal.RootName()[0:prefixLen]
+ return boolLiteralCandidates(prefix, eType.Range())
+
+ case *hclsyntax.LiteralValueExpr:
+ if eType.Val.Type() == cty.Bool {
+ value := "false"
+ if eType.Val.True() {
+ value = "true"
+ }
+ prefixLen := pos.Byte - eType.Range().Start.Byte
+ prefix := value[0:prefixLen]
+ return boolLiteralCandidates(prefix, eType.Range())
+ }
+ }
+
+ return []lang.Candidate{}
+}
+
+func boolLiteralCandidates(prefix string, editRange hcl.Range) []lang.Candidate {
+ candidates := make([]lang.Candidate, 0)
+
+ if strings.HasPrefix("false", prefix) {
+ candidates = append(candidates, lang.Candidate{
+ Label: "false",
+ Detail: cty.Bool.FriendlyNameForConstraint(),
+ Kind: lang.BoolCandidateKind,
+ TextEdit: lang.TextEdit{
+ NewText: "false",
+ Snippet: "false",
+ Range: editRange,
+ },
+ })
+ }
+ if strings.HasPrefix("true", prefix) {
+ candidates = append(candidates, lang.Candidate{
+ Label: "true",
+ Detail: cty.Bool.FriendlyNameForConstraint(),
+ Kind: lang.BoolCandidateKind,
+ TextEdit: lang.TextEdit{
+ NewText: "true",
+ Snippet: "true",
+ Range: editRange,
+ },
+ })
+ }
+
+ return candidates
+}
+
+func ctyObjectToObjectAttributes(objType cty.Type) schema.ObjectAttributes {
+ attrTypes := objType.AttributeTypes()
+ objAttributes := make(schema.ObjectAttributes, len(attrTypes))
+
+ for name, attrType := range attrTypes {
+ aSchema := &schema.AttributeSchema{
+ Constraint: schema.LiteralType{
+ Type: attrType,
+ },
+ }
+ if objType.AttributeOptional(name) {
+ aSchema.IsOptional = true
+ } else {
+ aSchema.IsRequired = true
+ }
+ objAttributes[name] = aSchema
+ }
+
+ return objAttributes
+}