# Copyright 2022 Mattia Giambirtone & All Contributors
#
# 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.

import std/os
import std/sets
import std/tables
import std/hashes
import std/strutils
import std/terminal
import std/sequtils
import std/algorithm
import std/strformat

import errors
import config
import frontend/parsing/token
import frontend/parsing/ast
import frontend/parsing/lexer as l
import frontend/parsing/parser as p


type
    # Just a bunch of convenience type aliases
    TypedArgument* = tuple[name: string, kind: Type, default: TypedNode]
    TypeConstraint* = tuple[match: bool, kind: Type]

    PragmaKind* = enum
        ## A pragma type enumeration
        
        # "Immediate" pragmas are processed right
        # when they are encountered. This is useful
        # for some types of pragmas, such as those
        # that flick compile-time switches on or off
        # or that mark objects with some compile-time
        # property. "Delayed" pragmas, on the other hand,
        # are processed when their associated object is
        # used in some way. For example, the "error"
        # pragma, when associated to a function, causes
        # the compiler to raise a static error when
        # attempting to call said function, rather than
        # doing so at declaration time. This allows the
        # detection of errors such as trying to negate
        # unsigned integers without explicitly hardcoding
        # the check into the compiler (all that's needed
        # is a definition of the `-` operator that will
        # raise a static error once called)
        Immediate, Delayed

    Pragma* = object
        ## A pragma object. Pragmas are
        ## (usually) hooks into compiler
        ## functions or serve as markers
        ## for objects (for example, to
        ## signal that a function has no
        ## side effects or that a type is
        ## nullable)
        kind*: PragmaKind
        name*: string   # All pragmas have names
        arguments*: seq[Type]   # The arguments to the pragma. Must be values computable at compile time

    TypeKind* = enum
        ## An enumeration of compile-time
        ## types
        
        # Intrinsic (aka "built-in") types

        # Signed and unsigned integer types
        Int8, UInt8, Int16, UInt16, 
        Int32, UInt32, Int64, UInt64, 
        
        # Floating point types
        Float32, Float64,

        Char,      # A single ASCII character
        Byte,      # Basically an alias for char
        String,    # A string. No encoding is specified
        Function,  # A function
        TypeDecl,  # A type declaration
        Nil,       # The nil type (aka null)
        Nan,       # The value of NaN (Not a Number)
        Bool,      # Booleans (true and false)
        Inf,       # Negative and positive infinity
        # Note: nil, nan, true, false and inf are all singletons
        Typevar,   # A type variable is the type of a type. For example, the type of `int` is typevar 
        Generic,   # A parametrically polymorphic generic type
        Reference, # A managed (aka GC'ed) reference 
        Pointer,   # An unmanaged (aka malloc()-ed) reference
        Any,       # The "any" type is a placeholder for a single type (similar to Python's builtins.object)
        All,       # The all type means "any type or no type at all". It is not exposed outside of the compiler
        Union,     # An untagged type union (acts like an exclusive "logical or" constraint)
        Auto,      # An automatic type. The compiler infers the true type of the object from its value when necessary
        Enum,      # An enumeration type

    Type* = ref object
        ## A compile-time type
        case kind: TypeKind:
            of Generic:
                # A generic type
                constraints*: seq[TypeConstraint]  # The type's generic constraints. For example, 
                # fn foo[T*: int & ~uint](...) {...} would map to [(true, int), (false, uint)]
                name*: IdentExpr    # The generic's name (in our example above, this would be "T")
                asUnion*: bool  # A generic constraint is treated like a "logical and", which means all
                # of its constraints must be satisfied. This allows for parametric polymorphism to work,
                # but it woudln't allow to make use of the type with only one of the types of the constraint, 
                # which is pretty useless. When this value is set to true, which it isn't by default, the 
                # constraints turn into an exclusive "logical or" instead, meaning that any type in the constraints 
                # is a valid instance of the type itself. This allows the compiler to typecheck the type for all 
                # possible types in the constraint and then let the user instantiate said type with any of the types 
                # in said constraint. The field's name means "treat this generic constraint like a type union"
            of Union:
                # A type union
                types*: seq[TypeConstraint]
            of Reference:
                # A managed reference
                nullable*: bool    # Is null a valid value for this type? (false by default)
                value*: TypedNode  # The type the reference points to
            of Pointer:
                # An unmanaged reference. Much
                # like a raw pointer in C
                data*: TypedNode   # The type we point to
            of TypeDecl:
                # A user-defined type
                fields*: seq[TypedArgument]  # List of fields in the object. May be empty
                parent*: Type           # The parent of this object if inheritance is used. May be nil
                implements*: seq[Type]  # The interfaces this object implements. May be empty
            of Function:
                # A function-like object. Wraps regular
                # functions, lambdas, coroutines and generators
                isLambda*: bool                  # Is this a lambda (aka anonymous) function?
                isCoroutine*: bool               # Is this a coroutine?
                isGenerator*: bool               # Is this a generator?
                isAuto*: bool                    # Is this an automatic function?
                arguments*: seq[TypedArgument]   # The function's arguments
                forwarded*: bool                 # Is this a forward declaration?
                returnType*: Type                # The function's return type
            else:
                discard
        # Can this type be mutated?
        mutable: bool

    TypedNode* = ref object
        ## A typed AST node
        node*: ASTNode     # The original (typeless) AST node
        value*: Type       # The node's type

    NameKind* = enum
        ## A name enumeration type
        DeclType,     # Any type declaration
        Module

    Name* = ref object
        ## A name object. Name objects associate
        ## peon objects to identifiers
        case kind*: NameKind
            of Module:
                path*: string  # The module's path
            else:
                discard
        ident*: IdentExpr        # The name's identifier
        file*: string            # The file where this name is declared in
        belongsTo*: Name         # The function owning this name, if any
        obj*: TypedNode          # The name's associated object
        owner*: Name             # The module owning this name
        depth*: int              # The name's scope depth
        isPrivate*: bool         # Is this name private?
        isConst*: bool           # Is this name a constant?
        isLet*: bool             # Can this name's value be mutated?
        isGeneric*: bool         # Is this a generic type?
        line*: int               # The line where this name is declared
        resolved*: bool          # Has this name ever been used?
        node*: Declaration       # The declaration associated with this name
        exports*: HashSet[Name]  # The modules to which this name is visible to
        isBuiltin*: bool         # Is this name a built-in?
        isReal*: bool            # Is this an actual name in user code? (The compiler
        # generates some names for its internal use and they may even duplicate existing
        # ones, so that is why we need this attribute)

    WarningKind* {.pure.} = enum
        ## A warning enumeration type
        UnreachableCode, UnusedName, ShadowOuterScope,
        MutateOuterScope

    CompileMode* {.pure.} = enum
        ## A compilation mode enumeration
        Debug, Release

    CompileError* = ref object of PeonException
        node*: ASTNode
        function*: Declaration
        compiler*: Compiler

    Compiler* = ref object
        ## The peon compiler
        ast: seq[Declaration]                  # The (typeless) AST of the current module
        current: int                           # Index into self.ast of the current node we're compiling
        file*: string                          # The current file being compiled (used only for error reporting)
        depth*: int                            # The current scope depth. If > 0, we're in a local scope, otherwise it's global
        replMode*: bool                        # Are we in REPL mode?
        names*: seq[Name]                      # List of all currently declared names
        lines*: seq[tuple[start, stop: int]]   # Stores line data for error reporting
        source*: string                        # The source of the current module, used for error reporting
        # We store these objects to compile modules
        lexer*: Lexer
        parser*: Parser
        isMainModule*: bool                    # Are we compiling the main module?
        disabledWarnings*: seq[WarningKind]    # List of disabled warnings
        showMismatches*: bool                  # Whether to show detailed info about type mismatches when we dispatch
        mode*: CompileMode                     # Are we compiling in debug mode or release mode?
        currentFunction*: Name                 # The current function being compiled
        currentModule*: Name                   # The current module being compiled
        parentModule*: Name                    # The module importing us, if any
        modules*: HashSet[Name]                # Currently imported modules


# Makes our name objects hashable
func hash(self: Name): Hash {.inline.} = self.ident.token.lexeme.hash()

proc `$`*(self: Name): string = $(self[])
proc `$`(self: Type): string = $(self[])
proc `$`(self: TypedNode): string = $(self[])


# Public getters for nicer error formatting
func getCurrentNode*(self: Compiler): ASTNode {.inline.} = (if self.current >= self.ast.len(): self.ast[^1] else: self.ast[self.current - 1])
func getCurrentFunction*(self: Compiler): Declaration {.inline.} = (if self.currentFunction.isNil(): nil else: self.currentFunction.node)
func getSource*(self: Compiler): string {.inline.} = self.source

# Utility functions

proc peek*(self: Compiler, distance: int = 0): ASTNode =
    ## Peeks at the AST node at the given distance.
    ## If the distance is out of bounds, the last
    ## AST node in the tree is returned. A negative
    ## distance may be used to retrieve previously
    ## consumed AST nodes
    if self.ast.high() == -1 or self.current + distance > self.ast.high() or self.current + distance < 0:
        result = self.ast[^1]
    else:
        result = self.ast[self.current + distance]


proc done*(self: Compiler): bool {.inline.} =
    ## Returns true if the compiler is done
    ## compiling, false otherwise
    result = self.current > self.ast.high()


proc error*(self: Compiler, message: string, node: ASTNode = nil) {.inline.} =
    ## Raises a CompileError exception
    let node = if node.isNil(): self.getCurrentNode() else: node
    raise CompileError(msg: message, node: node, line: node.token.line, file: node.file, compiler: self)


proc warning*(self: Compiler, kind: WarningKind, message: string, name: Name = nil, node: ASTNode = nil) =
    ## Raises a warning. Note that warnings are always disabled in REPL mode
    if self.replMode or kind in self.disabledWarnings:
        return
    var node: ASTNode = node
    var fn: Declaration
    if name.isNil():
        if node.isNil():
            node = self.getCurrentNode()
        fn = self.getCurrentFunction()
    else:
        node = name.node
        if node.isNil():
            node = self.getCurrentNode()
        if not name.belongsTo.isNil():
            fn = name.belongsTo.node
        else:
            fn = self.getCurrentFunction()
    var file = self.file
    if not name.isNil():
        file = name.owner.file
    var pos = node.getRelativeBoundaries()
    if file notin ["<string>", ""]:
        file = relativePath(file, getCurrentDir())
    stderr.styledWrite(fgYellow, styleBright, "Warning in ", fgRed, &"{file}:{node.token.line}:{pos.start}")
    if not fn.isNil() and fn.kind == funDecl:
        stderr.styledWrite(fgYellow, styleBright, " in function ", fgRed, FunDecl(fn).name.token.lexeme)
    stderr.styledWriteLine(styleBright, fgDefault, ": ", message)
    try:
        # We try to be as specific as possible with the warning message, pointing to the
        # line it belongs to, but since warnings are not always raised from the source
        # file they're generated in, we take into account the fact that retrieving the
        # exact warning location may fail and bail out silently if it does
        let line = readFile(file).splitLines()[node.token.line - 1].strip(chars={'\n'})
        stderr.styledWrite(fgYellow, styleBright, "Source line: ", resetStyle, fgDefault, line[0..<pos.start])
        stderr.styledWrite(fgYellow, styleUnderscore, line[pos.start..pos.stop])
        stderr.styledWriteLine(fgDefault, line[pos.stop + 1..^1])
    except IOError:
        discard
    except OSError:
        discard
    except IndexDefect:
        # Something probably went wrong (wrong line metadata): bad idea to crash!
        discard


proc step*(self: Compiler): ASTNode {.inline.} =
    ## Steps to the next node and returns
    ## the consumed one
    result = self.peek()
    if not self.done():
        self.current += 1

# Some forward declarations
proc compareUnions*(self: Compiler, a, b: seq[tuple[match: bool, kind: Type]]): bool
proc expression*(self: Compiler, node: Expression, compile: bool = true): TypedNode {.discardable.} = nil
proc identifier*(self: Compiler, node: IdentExpr, name: Name = nil, compile: bool = true, strict: bool = true): TypedNode {.discardable.} = nil
proc call*(self: Compiler, node: CallExpr, compile: bool = true): TypedNode {.discardable.} = nil
proc getItemExpr*(self: Compiler, node: GetItemExpr, compile: bool = true, matching: Type = nil): TypedNode {.discardable.} = nil
proc unary*(self: Compiler, node: UnaryExpr, compile: bool = true): TypedNode {.discardable.} = nil
proc binary*(self: Compiler, node: BinaryExpr, compile: bool = true): TypedNode {.discardable.} = nil
proc lambdaExpr*(self: Compiler, node: LambdaExpr, compile: bool = true): TypedNode {.discardable.} = nil
proc literal*(self: Compiler, node: ASTNode, compile: bool = true): TypedNode {.discardable.} = nil
proc infer*(self: Compiler, node: LiteralExpr): TypedNode
proc infer*(self: Compiler, node: Expression): TypedNode
proc inferOrError*(self: Compiler, node: Expression): TypedNode
proc findByName*(self: Compiler, name: string): seq[Name]
proc findInModule*(self: Compiler, name: string, module: Name): seq[Name]
proc findByType*(self: Compiler, name: string, kind: Type): seq[Name]
proc compare*(self: Compiler, a, b: Type): bool
proc match*(self: Compiler, name: string, kind: Type, node: ASTNode = nil, allowFwd: bool = true): Name
proc prepareFunction*(self: Compiler, name: Name) = discard


proc resolve*(self: Compiler, name: string): Name =
    ## Traverses all existing namespaces and returns
    ## the first object with the given name. Returns
    ## nil when the name can't be found. Note that 
    ## when a type or function declaration is first 
    ## resolved, it is also compiled on-the-fly
    for obj in reversed(self.names):
        if obj.ident.token.lexeme == name:
            if obj.owner.path != self.currentModule.path:
                # We don't own this name, but we
                # may still have access to it
                if obj.isPrivate:
                    # Name is private in its owner
                    # module, so we definitely can't
                    # use it
                    continue
                elif self.currentModule in obj.exports:
                    # The name is public in its owner
                    # module and said module has explicitly
                    # exported it to us: we can use it
                    result = obj
                    break
                # If the name is public but not exported in
                # its owner module, then we act as if it's
                # private. This is to avoid namespace pollution
                # from imports (i.e. if module A imports modules
                # C and D and module B imports module A, then B
                # might not want to also have access to C's and D's
                # names as they might clash with its own stuff)
                continue
            result = obj
            result.resolved = true
            break


proc resolve*(self: Compiler, name: IdentExpr): Name =
    ## Version of resolve that takes Identifier
    ## AST nodes instead of strings
    return self.resolve(name.token.lexeme)


proc resolveOrError*[T: IdentExpr | string](self: Compiler, name: T): Name =
    ## Calls self.resolve() and errors out with an appropriate
    ## message if it returns nil
    result = self.resolve(name)
    if result.isNil():
        when T is IdentExpr:
            self.error(&"reference to undefined name '{name.token.lexeme}'", name)
        when T is string:
            self.error(&"reference to undefined name '{name}'")


proc compare*(self: Compiler, a, b: Type): bool =
    ## Compares two type objects
    ## for equality
    result = false
    # Note: 'All' is a type internal to the peon
    # compiler that cannot be generated from user
    # code in any way. It's used mostly for matching
    # function return types (at least until we don't
    # have return type inference) and it matches any
    # type, including nil
    if a.isNil():
        return b.isNil() or b.kind == All
    elif b.isNil():
        return a.isNil() or a.kind == All
    elif a.kind == All or b.kind == All:
        return true
    elif a.kind == b.kind:
        # Here we compare types with the same kind discriminant
        case a.kind:
            of Int8, UInt8, Int16, UInt16, Int32,
               UInt32, Int64, UInt64, Float32, Float64,
               Char, Byte, String, Nil, TypeKind.Nan, Bool, TypeKind.Inf, Any:
                return true
            of Union:
                return self.compareUnions(a.types, b.types)
            of Generic:
                return self.compareUnions(a.constraints, b.constraints)
            of Reference, Pointer:
                # Here we already know that both
                # a and b are of either of the two
                # types in this branch, so we just need
                # to compare their values
                return self.compare(a.value.value, b.value.value)
            of Function:
                # Functions are a bit trickier to compare
                if a.arguments.len() != b.arguments.len():
                    return false
                if a.isCoroutine != b.isCoroutine or a.isGenerator != b.isGenerator:
                    return false
                if not self.compare(b.returnType, a.returnType):
                    return false
                var i = 0
                for (argA, argB) in zip(a.arguments, b.arguments):
                    # When we compare functions with forward 
                    # declarations, or forward declarations 
                    # between each other, we need to be more
                    # strict (as in: check argument names and 
                    # their default values, any pragma associated 
                    # with the function, and whether they are pure)
                    if a.forwarded:
                        if b.forwarded:
                            if argA.name != argB.name:
                                return false
                        else:
                            if argB.name == "":
                                # An empty argument name means
                                # we crafted this type object
                                # manually, so we don't need
                                # to match the argument name 
                                continue
                            if argA.name != argB.name:
                                return false
                    elif b.forwarded:
                        if a.forwarded:
                            if argA.name != argB.name:
                                return false
                        else:
                            if argA.name == "":
                                continue
                            if argA.name != argB.name:
                                return false
                    if not self.compare(argA.kind, argB.kind):
                        return false
                return true
            else:
                discard  # TODO: Custom types, enums
    elif a.kind == Union:
        for constraint in a.types:
            if self.compare(constraint.kind, b) and constraint.match:
                return true
        return false
    elif b.kind == Union:
        for constraint in b.types:
            if self.compare(constraint.kind, a) and constraint.match:
                return true
        return false
    elif a.kind == Generic:
        if a.asUnion:
            for constraint in a.constraints:
                if self.compare(constraint.kind, b) and constraint.match:
                    return true
            return false
        else:
            for constraint in a.constraints:
                if not self.compare(constraint.kind, b) or not constraint.match:
                    return false
            return true
    elif b.kind == Generic:
        if b.asUnion:
            for constraint in b.constraints:
                if self.compare(constraint.kind, a) and constraint.match:
                    return true
            return false
        else:
            for constraint in b.constraints:
                if not self.compare(constraint.kind, a) or not constraint.match:
                    return false
                return true
    elif a.kind == Any or b.kind == Any:
        # Here we already know that neither of
        # these types are nil, so we can always
        # just return true
        return true
    return false


proc compareUnions*(self: Compiler, a, b: seq[tuple[match: bool, kind: Type]]): bool =
    ## Compares type unions between each other
    var
        long = a
        short = b
    if b.len() > a.len():
        long = b
        short = a
    var i = 0
    for cond1 in short:
        for cond2 in long:
            if not self.compare(cond1.kind, cond2.kind) or cond1.match != cond2.match:
                continue
            inc(i)
    return i >= short.len()


proc toIntrinsic*(name: string): Type =
    ## Converts a string to an intrinsic
    ## type if it is valid and returns nil
    ## otherwise
    if name == "any":
        return Type(kind: Any)
    elif name == "all":
        return Type(kind: All)
    elif name == "auto":
        return Type(kind: Auto)
    elif name in ["int", "int64", "i64"]:
        return Type(kind: Int64)
    elif name in ["uint64", "u64", "uint"]:
        return Type(kind: UInt64)
    elif name in ["int32", "i32"]:
        return Type(kind: Int32)
    elif name in ["uint32", "u32"]:
        return Type(kind: UInt32)
    elif name in ["int16", "i16", "short"]:
        return Type(kind: Int16)
    elif name in ["uint16", "u16"]:
        return Type(kind: UInt16)
    elif name in ["int8", "i8"]:
        return Type(kind: Int8)
    elif name in ["uint8", "u8"]:
        return Type(kind: UInt8)
    elif name in ["f64", "float", "float64"]:
        return Type(kind: Float64)
    elif name in ["f32", "float32"]:
        return Type(kind: Float32)
    elif name in ["byte", "b"]:
        return Type(kind: Byte)
    elif name in ["char", "c"]:
        return Type(kind: Char)
    elif name == "nan":
        return Type(kind: TypeKind.Nan)
    elif name == "nil":
        return Type(kind: Nil)
    elif name == "inf":
        return Type(kind: TypeKind.Inf)
    elif name == "bool":
        return Type(kind: Bool)
    elif name == "typevar":
        return Type(kind: Typevar)
    elif name == "string":
        return Type(kind: String)


proc infer*(self: Compiler, node: LiteralExpr): TypedNode =
    ## Infers the type of a given literal expression
    if node.isNil():
        return nil
    case node.kind:
        of intExpr, binExpr, octExpr, hexExpr:
            let size = node.token.lexeme.split("'")
            if size.len() == 1:
                return TypedNode(node: node, value: Type(kind: Int64))
            let typ = size[1].toIntrinsic()
            if not self.compare(typ, nil):
                return TypedNode(node: node, value: typ)
            else:
                self.error(&"invalid type specifier '{size[1]}' for int", node)
        of floatExpr:
            let size = node.token.lexeme.split("'")
            if size.len() == 1:
                return  TypedNode(node: node, value: Type(kind: Float64))
            let typ = size[1].toIntrinsic()
            if not typ.isNil():
                return  TypedNode(node: node, value: typ)
            else:
                self.error(&"invalid type specifier '{size[1]}' for float", node)
        of trueExpr:
            return  TypedNode(node: node, value: Type(kind: Bool))
        of falseExpr:
            return  TypedNode(node: node, value: Type(kind: Bool))
        of strExpr:
            return  TypedNode(node: node, value: Type(kind: String))
        else:
            discard # Unreachable


proc infer*(self: Compiler, node: Expression): TypedNode =
    ## Infers the type of a given expression and
    ## returns it
    if node.isNil():
        return nil
    case node.kind:
        of NodeKind.identExpr:
            result = self.identifier(IdentExpr(node), compile=false, strict=false)
        of NodeKind.unaryExpr:
            result = self.unary(UnaryExpr(node), compile=false)
        of NodeKind.binaryExpr:
            result = self.binary(BinaryExpr(node), compile=false)
        of {NodeKind.intExpr, NodeKind.hexExpr, NodeKind.binExpr, NodeKind.octExpr,
            NodeKind.strExpr, NodeKind.falseExpr, NodeKind.trueExpr, NodeKind.floatExpr
            }:
            result = self.infer(LiteralExpr(node))
        of NodeKind.callExpr:
            result = self.call(CallExpr(node), compile=false)
        of NodeKind.refExpr:
            result =  TypedNode(node: node, value: Type(kind: Reference, value: self.infer(Ref(node).value)))
        of NodeKind.ptrExpr:
            result =  TypedNode(node: node, value: Type(kind: Pointer, data: self.infer(Ptr(node).value)))
        of NodeKind.groupingExpr:
            result = self.infer(GroupingExpr(node).expression)
        of NodeKind.getItemExpr:
            result = self.getItemExpr(GetItemExpr(node), compile=false)
        of NodeKind.lambdaExpr:
            result = self.lambdaExpr(LambdaExpr(node), compile=false)
        else:
            discard # TODO


proc inferOrError*(self: Compiler, node: Expression): TypedNode =
    ## Attempts to infer the type of
    ## the given expression and raises an 
    ## error if it fails
    result = self.infer(node)
    if result.isNil():
        self.error("expression has no type", node)


proc stringify*(self: Compiler, typ: Type): string =
    ## Returns the string representation of a
    ## type object
    if typ.isNil():
        return "nil"
    case typ.kind:
        of Int8, UInt8, Int16, UInt16, Int32,
           UInt32, Int64, UInt64, Float32, Float64,
           Char, Byte, String, Nil, TypeKind.Nan, Bool,
           TypeKind.Inf, Auto:
            result &= ($typ.kind).toLowerAscii()
        of Pointer:
            result &= &"ptr {self.stringify(typ)}"
        of Reference:
            result &= &"ref {self.stringify(typ)}"
        of Any:
            return "any"
        of Union:
            for i, condition in typ.types:
                if i > 0:
                    result &= " | "
                if not condition.match:
                    result &= "~"
                result &= self.stringify(condition.kind)
        of Generic:
            for i, condition in typ.constraints:
                if i > 0:
                    result &= " | "
                if not condition.match:
                    result &= "~"
                result &= self.stringify(condition.kind)
        else:
            discard

proc stringify*(self: Compiler, typ: TypedNode): string =
    ## Returns the string representation of a
    ## type object
    if typ.isNil():
        return "nil"
    case typ.value.kind:
        of Int8, UInt8, Int16, UInt16, Int32,
           UInt32, Int64, UInt64, Float32, Float64,
           Char, Byte, String, Nil, TypeKind.Nan, Bool,
           TypeKind.Inf, Auto, Pointer, Reference, Any,
           Union, Generic:
            result &= self.stringify(typ.value)
        of Function:
            result &= "fn ("
            for i, (argName, argType, argDefault) in typ.value.arguments:
                result &= &"{argName}: {self.stringify(argType)}"
                if not argDefault.isNil():
                    result &= &" = {argDefault}"
                if i < typ.value.arguments.len() - 1:
                    result &= ", "
            result &= ")"
            if not typ.value.returnType.isNil():
                result &= &": {self.stringify(typ.value.returnType)}"
            var node = Declaration(typ.node)
            if node.pragmas.len() > 0:
                result &= " {"
            for i, pragma in node.pragmas:
                result &= &"{pragma.name.token.lexeme}"
                if pragma.args.len() > 0:
                    result &= ": "
                    for j, arg in pragma.args:
                        result &= arg.token.lexeme
                        if j < pragma.args.high():
                            result &= ", "
                if i < node.pragmas.high():
                    result &= ", "
                else:
                    result &= "}"
        else:
            discard


proc findByName*(self: Compiler, name: string): seq[Name] =
    ## Looks for objects that have been already declared
    ## with the given name. Returns all objects that apply.
    for obj in reversed(self.names):
        if obj.ident.token.lexeme == name:
            if obj.owner.path != self.currentModule.path:
                if obj.isPrivate or self.currentModule notin obj.exports:
                    continue
            result.add(obj)


proc findInModule*(self: Compiler, name: string, module: Name): seq[Name] =
    ## Looks for objects that have been already declared as
    ## public within the given module with the given name. 
    ## Returns all objects that apply. If the name is an 
    ## empty string, returns all objects within the given 
    ## module, regardless of whether they are exported to
    ## the current one or not
    if name == "":
        for obj in reversed(self.names):
            if not obj.isPrivate and obj.owner == module:
                result.add(obj)
    else:
        for obj in self.findInModule("", module):
            if obj.ident.token.lexeme == name and self.currentModule in obj.exports:
                result.add(obj)


proc findByType*(self: Compiler, name: string, kind: Type): seq[Name] =
    ## Looks for objects that have already been declared
    ## with the given name and type. Returns all objects
    ## that apply
    for name in self.findByName(name):
        if self.compare(name.obj.value, kind):
            result.add(name)


proc findAtDepth*(self: Compiler, name: string, depth: int): seq[Name] {.used.} =
    ## Looks for objects that have been already declared
    ## with the given name at the given scope depth.
    ## Returns all objects that apply
    for obj in self.findByName(name):
        if obj.depth == depth:
            result.add(obj)


proc check*(self: Compiler, term: Expression, kind: Type) {.inline.} = 
    ## Checks the type of term against a known type.
    ## Raises an error if appropriate and returns
    ## otherwise
    let k = self.inferOrError(term)
    if not self.compare(k.value, kind):
        self.error(&"expecting value of type {self.stringify(kind)}, got {self.stringify(k)}", term)
    elif k.value.kind == Any and kind.kind != Any:
        self.error(&"any is not a valid type in this context")


proc isAny*(typ: Type): bool =
    ## Returns true if the given type is
    ## of (or contains) the any type
    case typ.kind:
        of Any:
            return true
        of Generic:
            for condition in typ.constraints:
                if condition.kind.isAny():
                    return true
        of Union:
            for condition in typ.types:
                if condition.kind.isAny():
                    return true
        else:
            return false


proc match*(self: Compiler, name: string, kind: Type, node: ASTNode = nil, allowFwd: bool = true): Name =
    ## Tries to find a matching function implementation
    ## compatible with the given type and returns its
    ## name object
    var impl: seq[Name] = self.findByType(name, kind)
    if impl.len() == 0:
        let names = self.findByName(name)
        var msg = &"failed to find a suitable implementation for '{name}'"
        if names.len() > 0:
            msg &= &", found {len(names)} potential candidate"
            if names.len() > 1:
                msg &= "s"
            if self.showMismatches:
                msg &= ":"
                for name in names:
                    msg &= &"\n - in {relativePath(name.file, getCurrentDir())}:{name.ident.token.line}:{name.ident.token.relPos.start} -> {self.stringify(name.obj.value)}"
                    if name.obj.value.kind != Function:
                        msg &= ": not a callable"
                    elif kind.arguments.len() != name.obj.value.arguments.len():
                        msg &= &": wrong number of arguments (expected {name.obj.value.arguments.len()}, got {kind.arguments.len()})"
                    else:
                        for i, arg in kind.arguments:
                            if not self.compare(arg.kind, name.obj.value.arguments[i].kind):
                                msg &= &": first mismatch at position {i + 1}: (expected {self.stringify(name.obj.value.arguments[i].kind)}, got {self.stringify(arg.kind)})"
                                break
            else:
                msg &= " (compile with --showMismatches for more details)"
        else:
            msg = &"call to undefined function '{name}'"
        self.error(msg, node)
    elif impl.len() > 1:
        # If we happen to find more than one match, we try again
        # and ignore forward declarations and automatic functions
        impl = filterIt(impl, not it.obj.value.forwarded and not it.obj.value.isAuto)
        if impl.len() > 1:
            # If there's *still* more than one match, then it's an error
            var msg = &"multiple matching implementations of '{name}' found"
            if self.showMismatches:
                msg &= ":"
                for fn in reversed(impl):
                    msg &= &"\n- in {relativePath(fn.file, getCurrentDir())}, line {fn.line} of type {self.stringify(fn.obj.value)}"
            else:
                msg &= " (compile with --showMismatches for more details)"
            self.error(msg, node)
    # This is only true when we're called by self.patchForwardDeclarations()
    if impl[0].obj.value.forwarded and not allowFwd:
        self.error(&"expecting an implementation for function '{impl[0].ident.token.lexeme}' declared in module '{impl[0].owner.ident.token.lexeme}' at line {impl[0].ident.token.line} of type '{self.stringify(impl[0].obj.value)}'")
    result = impl[0]
    for (a, b) in zip(result.obj.value.arguments, kind.arguments):
        if not a.kind.isAny() and b.kind.isAny():
            self.error("any is not a valid type in this context", node)


proc beginScope*(self: Compiler) =
    ## Begins a new local scope by incrementing the current
    ## scope's depth
    inc(self.depth)


proc unpackGenerics*(self: Compiler, condition: Expression, list: var seq[tuple[match: bool, kind: Type]], accept: bool = true) =
    ## Recursively unpacks a type constraint in a generic type
    case condition.kind:
        of identExpr:
            list.add((accept, self.inferOrError(condition).value))
            if list[^1].kind.kind == Auto:
                self.error("automatic types cannot be used within generics", condition)
        of binaryExpr:
            let condition = BinaryExpr(condition)
            case condition.operator.lexeme:
                of "|":
                    self.unpackGenerics(condition.a, list)
                    self.unpackGenerics(condition.b, list)
                else:
                    self.error("invalid type constraint in generic declaration", condition)
        of unaryExpr:
            let condition = UnaryExpr(condition)
            case condition.operator.lexeme:
                of "~":
                    self.unpackGenerics(condition.a, list, accept=false)
                else:
                    self.error("invalid type constraint in generic declaration", condition)
        else:
            self.error("invalid type constraint in generic declaration", condition)


proc unpackUnion*(self: Compiler, condition: Expression, list: var seq[tuple[match: bool, kind: Type]], accept: bool = true) =
    ## Recursively unpacks a type union
    case condition.kind:
        of identExpr:
            list.add((accept, self.inferOrError(condition).value))
        of binaryExpr:
            let condition = BinaryExpr(condition)
            case condition.operator.lexeme:
                of "|":
                    self.unpackUnion(condition.a, list)
                    self.unpackUnion(condition.b, list)
                else:
                    self.error("invalid type constraint in type union", condition)
        of unaryExpr:
            let condition = UnaryExpr(condition)
            case condition.operator.lexeme:
                of "~":
                    self.unpackUnion(condition.a, list, accept=false)
                else:
                    self.error("invalid type constraint in type union", condition)
        else:
            self.error("invalid type constraint in type union", condition)


proc dispatchPragmas(self: Compiler, name: Name) = discard
proc dispatchDelayedPragmas(self: Compiler, name: Name) = discard


proc declare*(self: Compiler, node: ASTNode): Name {.discardable.} =
    ## Statically declares a name into the current scope.
    ## "Declaring" a name only means updating our internal
    ## list of identifiers so that further calls to resolve()
    ## correctly return them. There is no code to actually
    ## declare a variable at runtime: the value is already
    ## on the stack
    var declaredName: string = ""
    var n: Name
    if self.names.high() > 16777215:
        # If someone ever hits this limit in real-world scenarios, I swear I'll
        # slap myself 100 times with a sign saying "I'm dumb". Mark my words
        self.error("cannot declare more than 16777215 names at a time")
    case node.kind:
        of NodeKind.varDecl:
            var node = VarDecl(node)
            declaredName = node.name.token.lexeme
            # Creates a new Name entry so that self.identifier emits the proper stack offset
            self.names.add(Name(depth: self.depth,
                                ident: node.name,
                                isPrivate: node.isPrivate,
                                owner: self.currentModule,
                                file: self.file,
                                isConst: node.isConst,
                                obj: nil,  # Done later
                                isLet: node.isLet,
                                line: node.token.line,
                                belongsTo: self.currentFunction,
                                kind: DeclType,
                                node: node,
                                isReal: true
                                ))
            n = self.names[^1]
        of NodeKind.funDecl:
            var node = FunDecl(node)
            declaredName = node.name.token.lexeme
            var fn = Name(depth: self.depth,
                          isPrivate: node.isPrivate,
                          isConst: false,
                          owner: self.currentModule,
                          file: self.file,
                          obj: TypedNode(node: node, 
                                        value: Type(kind: Function,
                                                    returnType: nil,  # We check it later
                                                    arguments: @[],
                                                    forwarded: node.body.isNil(),
                                                    isAuto: false)
                                        ),
                          ident: node.name,
                          node: node,
                          isLet: false,
                          line: node.token.line,
                          kind: DeclType,
                          belongsTo: self.currentFunction,
                          isReal: true)
            if node.generics.len() > 0:
                n.isGeneric = true
            var typ: Type
            for argument in node.arguments:
                typ = self.infer(argument.valueType).value
                if not typ.isNil() and typ.kind == Auto:
                    n.obj.value.isAuto = true
                    if n.isGeneric:
                        self.error("automatic types cannot be used within generics", argument.valueType)
                    break
            typ = self.infer(node.returnType).value
            if not typ.isNil() and typ.kind == Auto:
                n.obj.value.isAuto = true
                if n.isGeneric:
                    self.error("automatic types cannot be used within generics", node.returnType)
            self.names.add(fn)
            self.prepareFunction(fn)
            n = fn
        of NodeKind.importStmt:
            var node = ImportStmt(node)
            # We change the name of the module internally so that
            # if you import /path/to/mod, then doing mod.f() will
            # still work without any extra work on our end. Note how
            # we don't change the metadata about the identifier's 
            # position so that error messages still highlight the
            # full path
            let path = node.moduleName.token.lexeme
            node.moduleName.token.lexeme = node.moduleName.token.lexeme.extractFilename()
            self.names.add(Name(depth: self.depth,
                                owner: self.currentModule,
                                file: "",  # The file of the module isn't known until it's compiled!
                                path: path,
                                ident: node.moduleName,
                                line: node.moduleName.token.line,
                                kind: NameKind.Module,
                                isPrivate: false,
                                isReal: true
                            ))
            n = self.names[^1]
            declaredName = self.names[^1].ident.token.lexeme
        of NodeKind.typeDecl:
            var node = ast.TypeDecl(node)
            self.names.add(Name(kind: DeclType,
                                depth: self.depth,
                                owner: self.currentModule,
                                node: node,
                                ident: node.name,
                                line: node.token.line,
                                isPrivate: node.isPrivate,
                                isReal: true,
                                belongsTo: self.currentFunction,
                                obj: TypedNode(node: node, value: Type(kind: TypeDecl))
                                )
                          )
            n = self.names[^1]
            declaredName = node.name.token.lexeme
            if node.value.isNil():
                discard   # TODO: Fields
            else:
                case node.value.kind:
                    of identExpr:
                        n.obj.value = self.inferOrError(node.value).value
                    of binaryExpr:
                        # Type union
                        n.obj.value = Type(kind: Union, types: @[])
                        self.unpackUnion(node.value, n.obj.value.types)
                    else:
                        discard
        else:
            discard # TODO: enums
    if not n.isNil():
        self.dispatchPragmas(n)
    for name in self.findByName(declaredName):
        if name == n:
            continue
        # We don't check for name clashes with functions because self.match() does that
        if name.kind == DeclType and name.depth == n.depth and name.owner == n.owner:
            self.error(&"re-declaration of {declaredName} is not allowed (previously declared in {name.owner.ident.token.lexeme}:{name.ident.token.line}:{name.ident.token.relPos.start})")
    # We emit a bunch of warnings, mostly for QoL
    for name in self.names:
        if name == n:
            break
        if name.ident.token.lexeme != declaredName:
            continue
        if name.owner != n.owner and (name.isPrivate or n.owner notin name.exports):
            continue
        if name.kind == DeclType:
            if name.depth < n.depth:
                self.warning(WarningKind.ShadowOuterScope, &"'{declaredName}' at depth {name.depth} shadows a name from an outer scope ({name.owner.file}.pn:{name.ident.token.line}:{name.ident.token.relPos.start})", n)
            if name.owner != n.owner:
                self.warning(WarningKind.ShadowOuterScope, &"'{declaredName}' at depth {name.depth} shadows a name from an outer module ({name.owner.file}.pn:{name.ident.token.line}:{name.ident.token.relPos.start})", n)
    return n