TypeChecker API

from axon import Lexer, Parser, TypeChecker

source = '''
persona Expert {
    domain: ["medicine"]
    confidence_threshold: 1.5  # ERROR: must be 0.0-1.0
}

flow Analyze(doc: UnknownType) -> String {  # ERROR: UnknownType not defined
    step Process {
        ask: "Process the document"
    }
}
'''

lexer = Lexer(source)
parser = Parser(lexer.tokenize())
ast = parser.parse()

checker = TypeChecker(ast)
errors = checker.check()

for error in errors:
    print(f"Line {error.line}: {error.message}")

checker = TypeChecker(ast)
errors = checker.check()

if errors:
    print(f"Found {len(errors)} error(s):")
    for err in errors:
        print(f"  {err.line}:{err.column} - {err.message}")
else:
    print("Program is semantically valid")

              Any
             / | \
            /  |  \
           /   |   \
FactualClaim Opinion Uncertainty
     |        
  CitedFact
     |
HighConfidenceFact

checker = TypeChecker(ast)

# Check if source type can be used where target type is expected
can_use = checker.check_type_compatible(
    source="CitedFact",
    target="FactualClaim"
)
print(can_use)  # True (CitedFact is a subtype of FactualClaim)

can_use = checker.check_type_compatible(
    source="Opinion",
    target="FactualClaim" 
)
print(can_use)  # False (Opinion cannot be used as FactualClaim)

# If any input is Uncertain, output becomes Uncertain
result_type = checker.check_uncertainty_propagation([
    "FactualClaim",
    "Uncertainty",
    "String"
])
print(result_type)  # "Uncertain[Any]" - uncertainty propagates

source = '''
persona Expert {
    tone: invalid_tone  # Error: unknown tone
    confidence_threshold: 1.5  # Error: must be 0.0-1.0
}
'''

source = '''
context Production {
    memory: invalid_scope  # Error: unknown memory scope
    depth: shallow_deep  # Error: unknown depth
    temperature: 5.0  # Error: must be 0.0-2.0
    max_tokens: -100  # Error: must be positive
}
'''

source = '''
anchor NoHallucination {
    confidence_floor: 1.5  # Error: must be 0.0-1.0
    on_violation: unknown_action  # Error: invalid action
}
'''

source = '''
flow Process(doc: UnknownType) -> String {  # Error: UnknownType not defined
    step Extract {
        ask: "Extract data"
        confidence_floor: 2.0  # Error: must be 0.0-1.0
    }
    
    step Extract {  # Error: duplicate step name
        ask: "Extract again"
    }
}
'''

source = '''
run AnalyzeContract(contract)
    as UnknownPersona  # Error: persona not defined
    within UnknownContext  # Error: context not defined
    constrained_by [NoHallucination, UnknownAnchor]  # Error: anchor not defined
    effort: ultra  # Error: unknown effort level
'''

from axon import AxonTypeError

class AxonTypeError:
    message: str
    line: int
    column: int

try:
    errors = checker.check()
    if errors:
        for error in errors:
            print(f"Type error at {error.line}:{error.column}")
            print(f"  {error.message}")
except Exception as e:
    print(f"Unexpected error: {e}")

# Undefined type reference
errors = checker.check()  
# "Type 'MyCustomType' is not defined"

# Invalid epistemic coercion
errors = checker.check()
# "Cannot use Opinion where FactualClaim is expected"

# Range constraint violation
errors = checker.check()
# "confidence_threshold must be between 0.0 and 1.0, got 1.5"

# Duplicate declaration
errors = checker.check()
# "Duplicate declaration: 'Expert' already defined as persona"

source = '''
type Party {
    name: String
    role: String
}

type Contract {
    parties: List<Party>
    terms: String
    risk_score: RiskScore
}

flow Analyze(contract: Contract) -> RiskScore {
    step Assess {
        ask: "Assess contract risk"
        output: RiskScore
    }
}
'''

checker = TypeChecker(Parser(Lexer(source).tokenize()).parse())
errors = checker.check()
# No errors - all types are properly defined

from axon.compiler.type_checker import EpistemicLattice

# Check subtype relationship
is_sub = EpistemicLattice.is_subtype("CitedFact", "FactualClaim")
print(is_sub)  # True

# Compute join (supremum) - least upper bound
joined = EpistemicLattice.join("FactualClaim", "Opinion")
print(joined)  # "Any" - degradation to common ancestor

# Compute meet (infimum) - greatest lower bound
met = EpistemicLattice.meet("CitedFact", "FactualClaim")
print(met)  # "CitedFact" - more specific type

# Lift into Uncertainty monad
uncertain = EpistemicLattice.lift("FactualClaim", probability=0.6)
print(uncertain)  # "Uncertain[0.6, FactualClaim]"

from axon import Lexer, Parser, TypeChecker
import sys

def check_program(source_path: str) -> bool:
    """Type-check an AXON program file."""
    
    with open(source_path) as f:
        source = f.read()
    
    # Phase 1: Lexical analysis
    lexer = Lexer(source, filename=source_path)
    tokens = lexer.tokenize()
    
    # Phase 2: Parsing
    parser = Parser(tokens)
    ast = parser.parse()
    
    # Phase 3: Type checking
    checker = TypeChecker(ast)
    errors = checker.check()
    
    if errors:
        print(f"Type errors in {source_path}:")
        for error in errors:
            print(f"  Line {error.line}:{error.column}")
            print(f"    {error.message}")
        return False
    
    print(f"✓ {source_path} is semantically valid")
    return True

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python check.py <program.axon>")
        sys.exit(1)
    
    success = check_program(sys.argv[1])
    sys.exit(0 if success else 1)