func GetDef()

in internal/langserver/schema/schema.go [11:102]
92 lines of code
40 McCabe index (conditional complexity)

func GetDef(resourceType *types.TypeBase, hclNodes []*parser.HclNode, index int) []*types.TypeBase {
	if resourceType == nil {
		return nil
	}
	if len(hclNodes) == index {
		if t, ok := (*resourceType).(*types.DiscriminatedObjectType); ok {
			if discriminator, ok := hclNodes[index-1].Children[t.Discriminator]; ok && discriminator != nil && discriminator.Value != nil {
				if discriminatorValue := strings.Trim(*discriminator.Value, `"`); len(discriminatorValue) > 0 {
					if t.Elements[discriminatorValue] != nil && t.Elements[discriminatorValue].Type != nil {
						selectedDiscriminatedObjectType := &types.DiscriminatedObjectType{
							Name:           t.Name,
							Discriminator:  t.Discriminator,
							BaseProperties: t.BaseProperties,
							Elements: map[string]*types.TypeReference{
								discriminatorValue: t.Elements[discriminatorValue],
							},
						}
						return []*types.TypeBase{selectedDiscriminatedObjectType.AsTypeBase()}
					}
				}
			}
		}
		return []*types.TypeBase{resourceType}
	}
	key := hclNodes[index].Key
	switch t := (*resourceType).(type) {
	case *types.ArrayType:
		if t.ItemType != nil {
			if strings.Contains(key, ".") {
				return GetDef(t.ItemType.Type, hclNodes, index+1)
			}
			return GetDef(t.ItemType.Type, hclNodes, index)
		}
		return nil
	case *types.DiscriminatedObjectType:
		if value, ok := t.BaseProperties[key]; ok {
			if value.Type != nil {
				return GetDef(value.Type.Type, hclNodes, index+1)
			}
		}
		if index != 0 {
			if discriminator, ok := hclNodes[index-1].Children[t.Discriminator]; ok && discriminator != nil && discriminator.Value != nil {
				if discriminatorValue := strings.Trim(*discriminator.Value, `"`); len(discriminatorValue) > 0 {
					if t.Elements[discriminatorValue] != nil && t.Elements[discriminatorValue].Type != nil {
						return GetDef(t.Elements[discriminatorValue].Type, hclNodes, index)
					}
				}
			}
		}
		res := make([]*types.TypeBase, 0)
		for _, discriminator := range t.Elements {
			if resourceType := GetDef(discriminator.Type, hclNodes, index); resourceType != nil {
				res = append(res, resourceType...)
			}
		}
		return res
	case *types.ObjectType:
		if value, ok := t.Properties[key]; ok {
			if value.Type != nil {
				return GetDef(value.Type.Type, hclNodes, index+1)
			}
		}
		if t.AdditionalProperties != nil {
			return GetDef(t.AdditionalProperties.Type, hclNodes, index+1)
		}
	case *types.ResourceType:
		if t.Body != nil {
			return GetDef(t.Body.Type, hclNodes, index+1)
		}
	case *types.ResourceFunctionType:
		if t.Input != nil {
			return GetDef(t.Input.Type, hclNodes, index+1)
		}
	case *types.AnyType:
		return []*types.TypeBase{resourceType}
	case *types.BooleanType:
		return []*types.TypeBase{resourceType}
	case *types.IntegerType:
		return []*types.TypeBase{resourceType}
	case *types.StringType:
		return []*types.TypeBase{resourceType}
	case *types.StringLiteralType:
		return []*types.TypeBase{resourceType}
	case *types.UnionType:
		res := make([]*types.TypeBase, 0)
		for _, element := range t.Elements {
			res = append(res, GetDef(element.Type, hclNodes, index)...)
		}
		return res
	}
	return nil
}