declaration.go

package analysis

import (
	"fmt"

	"github.com/ProCode-Software/klar/internal/ast"
	"github.com/ProCode-Software/klar/internal/klarerrs"
	"github.com/ProCode-Software/klar/internal/ranges"
)

type DeclarationInfo struct {
	// [*ast.FunctionDeclaration], [*ast.FuncAliasDeclaration],
	// [ast.TypeDeclaration], or [ast.VariableDeclaration]
	node     ast.Statement
	varInfo  *varInfo // For var/const declaration.
	funcKind funcKind // For function declaration.
	receiver *Object  // For method or initializer. Should be [*TypeName]
}

type varInfo struct {
	lhs     ast.Destructurable // Where the variable was defined. Undestructured
	rhs     ast.Expression     // Undestructured RHS expression
	expType Type               // If the decl has an explicit type. Use as [*Expr.hint]
	// Set when rhs is checked, or the explicit type is known. Pointer is
	// never nil, but the *Expr can be.
	rhsExpr **Expr
	sctx    *stmtContext // Statement context the var/const was defined in
}

type funcKind uint8

const (
	normalFunc funcKind = iota
	methodFunc
	initFunc
)

// declareWithInfo declares an object into the given context with the
// given attributes and [DeclarationInfo]. If declareToCtx == false,
// only the object's information is recorded and is not added to the context.
// If *attrs != nil, the attributes are parsed and drained.
func (c *Checker) declareWithInfo(obj *Object, ctx *Context,
	attrs *[]*ast.Attribute, declareToCtx bool,
) {
	// Set the object's context even if it's not being declared into it
	obj.Context = ctx
	if declareToCtx {
		c.declare(ctx, obj)
	}
	// Parse the attributes if any (top-level only)
	if attrs != nil {
		obj.attrs = c.parseAttributes(
			*attrs, attrTargetKindOf(obj.info.node, obj.Public), obj.Range, obj.File,
		)
		*attrs = (*attrs)[:0]
	}
	if obj.Name == "_" {
		// Since the object won't be added to the context, it won't be checked.
		// For discarded idents, it's guaranteed there are no dependencies
		obj.Order = uint32(len(ctx.Declarations))
		c.checkDeclaration(obj)
	}
}

func (c *Checker) checkDeclaration(o *Object) {
	if c.debug() {
		c.logger.push(fmt.Sprintf(
			"%T declaration at %s", o.Type, o.FileRange(),
		))
		defer c.logger.pop()
	}
	/*
		Red: Type isn't known yet. Not in objPathIndex.
		White: Type is pending. Is in objPathIndex.
		Blue: Type is known. Not in objPathIndex.

		Blue can only depend on blue. White/grey can only depend on red or blue.
		A dependency on white is a (possibly invalid) cycle.

		When marked white, it is pushed onto the object path stack, and its index
		is recorded in objPathIndex. It's removed from the map and the stack when marked blue.
	*/
	if _, ok := c.objPathIndex[o]; ok {
		switch typ := o.Type.(type) {
		case *Variable:
			if !c.checkCycle(o) || typ.Type == nil {
				typ.Type = InvalidType
			}
		case *ConstantDecl:
			if !c.checkCycle(o) || typ.Type == nil {
				typ.Type = InvalidType
			}
		case *TypeName:
			if !c.checkCycle(o) {
				typ.Type = InvalidType
			}
		case *Function, *Overload:
			c.checkCycle(o) // TODO: is this needed?
		case *FunctionAlias:
		// TODO
		default:
			panic(fmt.Sprintf("unhandled declaration type: %T", o.Type))
		}
		if Underlying(o.Type) == nil {
			panic("underlying type is still nil")
		}
		return
	}

	if Underlying(o.Type) != nil {
		return // Blue, already checked
	}

	// White, not checked yet
	c.pushToPath(o)
	defer c.popPath()

	switch o.Type.(type) {
	case *Variable:
		c.checkVarDecl(o)
	case *ConstantDecl:
		c.checkConstDecl(o)
	case *TypeName:
		c.checkTypeDecl(o)
	case *Function:
		c.checkFuncDecl(o)
	case *Overload:
		return // Overloads are part of functions
	case *FunctionAlias:
		c.checkFuncAlias(o)
	default:
		panic(fmt.Sprintf("unhandled declaration type: %T", o.Type))
	}
}

// checkCycle checks if a cycle involving the given object is valid.
// An error is reported if checkCycle returns false.
func (c *Checker) checkCycle(o *Object) bool {
	start := c.objPathIndex[o]
	cycle := c.objPath[start:]
	// Number of type defs and values (const or var) in the cycle
	var typeDefCount, valCount int
	for _, obj := range cycle {
		switch typ := obj.Type.(type) {
		case *TypeName:
			if _, ok := typ.Type.(*TypeAlias); !ok {
				// Only increase the count for non-aliases
				typeDefCount++
			}
		case *Variable, *ConstantDecl:
			valCount++
		case *Function:
		default:
			panic(fmt.Sprintf("isValidCycle: unhandled declaration type: %T", obj.Type))
		}
	}
	switch {
	case valCount == len(cycle):
		// Go: A cycle involving only constants and variables is invalid but we
		// ignore them here because they are reported via the initialization
		// cycle check.
		return true
	case valCount == 0 && typeDefCount > 0:
		// A cycle involving only type definitions (and maybe functions) must have
		// at least 1 type definition to be valid. Alias-only cycles are invalid.
		return true
	default:
		// Invalid cycle
		c.error(cycleError(cycle))
		return false
	}
}

// collectMethods associates methods with the type with name typeName. The
// receiver for the methods is looked up within the context and validated.
func (c *Checker) collectMethods(ctx *Context, typeName string, methods []methodInfo) {
	if len(methods) == 0 {
		return
	}
	selfObj := ctx.Lookup(typeName)
	if selfObj == nil {
		c.validateReceiver(typeName, ctx.LookupRecursive(typeName), methods, true)
		return
	}
	if !c.validateReceiver(typeName, selfObj, methods, false) {
		return
	}
	self := Underlying(selfObj.Type).(SupportsMethods)
	for _, meth := range methods {
		meth.obj.info.funcKind = methodFunc
		meth.obj.info.receiver = selfObj
		if err := self.AddMethod(meth.obj); err != nil {
			if err.Code == klarerrs.ErrFieldAndMethodSameName {
				err.SetParam("type", typeName)
			}
			c.fileError(err, meth.obj.File)
			return
		}
	}
	// Typecheck the [*Function] or [*FunctionAlias] objects, not overloads from `methods`
	for _, obj := range self.GetMethods() {
		c.checkDeclaration(obj)
	}
}

// collectInitializers checks the signature of each initializer function and
// associates them with the type with name typeName. Each [*Object] in inits
// should have type [*Overload]. The type with name typeName is looked up
// within the context and validated.
func (c *Checker) collectInitializers(ctx *Context, typeName string, inits []*Overload) {
	identRange := func(obj *Object) ranges.Range {
		return obj.info.node.(*ast.FunctionDeclaration).Identifier.Range()
	}
	// TODO: typeName was already looked up in [Checker.getOverloadParent].
	// Don't repeat this process again, and move error reporting
	// for initializers in other scopes to that function.
	selfObj := ctx.Lookup(typeName)
	if selfObj == nil {
		selfObj = ctx.LookupRecursive(typeName)
		if selfObj == nil {
			// Undefined
			for _, o := range inits {
				err := klarerrs.Undefined(typeName, identRange(o.Object))
				c.fileError(err, o.File)
			}
			return
		}
		// Found, but in a different scope
		det := []klarerrs.Detail{{
			File:    selfObj.FilePath(),
			Range:   selfObj.Range,
			Message: klarerrs.Quote(typeName) + " was declared here",
		}}
		for _, o := range inits {
			node := o.info.node.(*ast.FunctionDeclaration)
			err := klarerrs.Node(klarerrs.ErrMethodInOtherScope, node)
			err.SetParam("initializer", true)
			err.Details = det
			c.fileError(err, o.File)
		}
		return
	}
	switch self := selfObj.TypeName().Type.(type) {
	case *Struct:
		self.Initializers = inits
	case *Enum:
		self.Initializers = inits
	case *TypeAlias:
		// Similar to method receivers, this can't be an alias
		for _, o := range inits {
			err := klarerrs.Range(klarerrs.ErrAliasSelfType, identRange(o.Object))
			err.SetParam("initializer", true)
			err.Label = "Initializer target can't be an alias"
			c.fileError(err, o.File)
		}
		return
	default:
		// Type doesn't support initializers
		for _, o := range inits {
			err := klarerrs.Range(klarerrs.ErrUnsupportedInitType, identRange(o.Object))
			err.Label = "Can't create initializers on this kind of type"
			c.fileError(err, o.File)
		}
		return
	}
	for _, obj := range inits {
		obj.info.funcKind = initFunc
		obj.info.receiver = selfObj
		c.checkOverload(obj.Type.(*Overload), nil)
	}
}

func (c *Checker) validateReceiver(name string, self *Object,
	methods []methodInfo, isOtherScope bool,
) bool {
	selfRange := func(meth methodInfo) ranges.Range {
		if meth.decl != nil {
			return meth.decl.SelfType.Range()
		} else {
			return meth.alias.SelfType.Range()
		}
	}
	// Error if:
	// - Object is nil
	// - Object is not a type
	// - Object is declared in another scope
	// - Object is in another module or is a builtin (TODO)
	// - Object is a type alias
	// - Object doesn't accept methods
	switch {
	case self == nil:
		// Self type doesn't exist
		for _, meth := range methods {
			err := klarerrs.Undefined(name, selfRange(meth))
			c.fileError(err, meth.obj.File)
		}
	case isOtherScope:
		// typeName was declared in a different scope from the method
		det := []klarerrs.Detail{{
			File:    self.FilePath(),
			Range:   self.Range,
			Message: klarerrs.Quote(name) + " was declared here",
		}}
		for _, meth := range methods {
			err := klarerrs.Node(klarerrs.ErrMethodInOtherScope, meth.decl)
			err.Details = det
			c.fileError(err, meth.obj.File)
		}
	case self.Module != methods[0].obj.Module:
		// TODO: check that receiver is not a primitive
		return false
	default:
		tn, ok := self.Type.(*TypeName)
		if !ok {
			// Receiver is not a type
			for _, m := range methods {
				err := klarerrs.Range(klarerrs.ErrUnsupportedSelfType, selfRange(m))
				err.Label = "This isn't a type"
				c.fileError(err, m.obj.File)
			}
			return false
		}
		switch tn.Type.(type) {
		case *TypeAlias:
			// Self type is a type alias
			for _, m := range methods {
				err := klarerrs.Range(klarerrs.ErrAliasSelfType, selfRange(m))
				err.Label = "Self type can't be an alias"
				c.fileError(err, m.obj.File)
			}
		default:
			// Self type doesn't support methods
			for _, m := range methods {
				err := klarerrs.Range(klarerrs.ErrUnsupportedSelfType, selfRange(m))
				err.Label = "Can't declare methods on this kind of type"
				c.fileError(err, m.obj.File)
			}
		case SupportsMethods:
			return true
		}
	}
	return false
}