public override void VisitTypeReferenceType(AstTypeReferenceType type)
{
if (type.HasSymbol)
{
type.Symbol.RemoveReference(type);
}
base.VisitTypeReferenceType(type);
}
private void AssignInferredType(AstExpressionOperand operand, AstTypeDefinition typeDef)
{
var typeRef = AstTypeReferenceType.From(typeDef);
typeRef.IsInferred = true;
SymbolTable !.Add(typeRef);
operand.SetTypeReference(typeRef);
}
public void AddFunction(AstFunctionDefinitionExternal function)
{
if (!function.FunctionType.HasTypeReference)
{
var typeRef = new AstTypeReferenceType(AstIdentifierIntrinsic.Void);
function.FunctionType.SetTypeReference(typeRef);
}
function.CreateSymbols(SymbolTable);
function.Symbol.SymbolLocality = AstSymbolLocality.Imported;
}
public override void VisitAssignment(AstAssignment assign)
{
Ast.Guard(assign.HasVariable, "AstVariable not set on assign.");
assign.VisitChildren(this);
if (assign.Variable is AstVariableReference varRef &&
varRef.VariableDefinition is null)
{
var symbol = varRef.Symbol;
AstTypeReference?typeRef = null;
// Variable.TypeReference is usually null.
if (varRef.HasTypeReference)
{
typeRef = varRef.TypeReference.MakeCopy();
}
// It is set only when type is explicitly in source code, or has been inferred.
var varDef = new AstVariableDefinition(typeRef);
varDef.SetIdentifier(varRef.Identifier);
varDef.SetSymbol(symbol);
symbol.RemoveReference(varRef);
AstSymbolReferenceRemover.RemoveReference(varRef);
symbol.AddNode(varDef);
assign.SetVariableDefinition(varDef);
// do the children again for types
assign.VisitChildren(this);
}
if (!assign.Variable !.HasTypeReference)
{
// typeless assign of var (x = 42)
var expr = assign.Expression;
var typeRef = expr.TypeReference;
Ast.Guard(typeRef.HasIdentifier, "AstIdentifier not set on AstTypeReference.");
var symbol = assign.Variable.Symbol;
var def = symbol.DefinitionAs <AstTypeDefinition>();
if (def is not null)
{
typeRef = AstTypeReferenceType.From(def);
assign.Variable.SetTypeReference(typeRef);
}
else
{
assign.Variable.SetTypeReference(typeRef.MakeCopy());
}
Visit(assign.Variable.TypeReference);
}
}
public override void VisitTypeReferenceType(AstTypeReferenceType type)
{
Ast.Guard(SymbolTable, "ResolveTypes has no SymbolTable.");
Ast.Guard(type.Identifier, "AstTypeReference or AstIdentifier is null.");
var success = type.TryResolveSymbol();
if (type.IsTemplateOrGeneric && type.TypeDefinition is null)
{
var typeTemplate = type.TemplateDefinition;
if (typeTemplate is null)
{
typeTemplate = FindTemplateDefinition <AstTypeDefinitionTemplate>(type, AstSymbolKind.Type);
}
if (typeTemplate is not null)
{
var symbolTable = type.Symbol.SymbolTable;
if (typeTemplate.IsTemplate)
{
if (typeTemplate is AstTypeDefinitionStruct structTemplate)
{
var typeDef = new AstTemplateInstanceStruct(structTemplate);
typeDef.Instantiate(type);
symbolTable.Add(typeDef);
Visit(typeDef);
}
else if (typeTemplate is AstTypeDefinitionIntrinsic intrinsicTemplate)
{
var typeDef = new AstTemplateInstanceType(intrinsicTemplate);
typeDef.Instantiate(type);
symbolTable.Add(typeDef);
Visit(typeDef);
}
else
{
throw new NotImplementedException("Template is of a Type that has not been implemented yet.");
}
}
if (typeTemplate.IsGeneric)
{
}
}
else
{
_context.UndefinedType(type);
}
}
if (!type.IsTemplateParameter && !type.Symbol.IsDefined)
{
if (!success && !type.IsExternal)
{
// TODO: for now unresolved external references are ignored.
_context.UndefinedType(type);
}
}
type !.VisitChildren(this);
}
public override void VisitTypeReferenceType(AstTypeReferenceType type)
{
type.TypeDefinition.Should().NotBeNull();
type.VisitChildren(this);
}
public virtual void VisitTypeReferenceType(AstTypeReferenceType type)
{
type.VisitChildren(this);
}
