protected CheckedType VarDestructuringNode(TypeCheckerVisitor checker, VariableDestructuringNode vardestnode)
{
var initType = vardestnode.Right.Visit(checker);
for (int i = 0; i < vardestnode.Left.Count; i++)
{
var declaration = vardestnode.Left[i];
if (declaration == null)
{
continue;
}
// Get the variable type from the declaration
var lhsType = checker.SymbolTable.GetVariableSymbol(declaration.Value).TypeSymbol;
var rhsType = (initType.TypeSymbol as Tuple).Elements[i];
// When lhs is "var", take the type from the right hand side expression, or throw if it is not available
/*if (!lhsType.Type.IsAssignableFrom(rhsType))
* throw new SymbolException($"Cannot assign type {rhsType} to variable of type {lhsType}");*/
}
return(null);
}
protected void VarDestructuringNode(SymbolResolverVisitor visitor, VariableDestructuringNode destrnode)
{
var types = destrnode.Right.Visit(visitor);
foreach (var declaration in destrnode.Left)
{
if (declaration == null)
{
continue;
}
// Get the identifier name
var variableName = declaration.Value;
// Check if the symbol is already defined
if (visitor.SymbolTable.HasVariableSymbol(variableName))
{
throw new SymbolException($"Symbol {variableName} is already defined.");
}
// If the type anotation is not specific (uses 'var'), we need to create an anonymous type
// for every variable. If not, we just get the type information from the token
var varType = destrnode.Information.Type.Type == Syntax.TokenType.Variable
? visitor.Inferrer.NewAnonymousType()
: SymbolHelper.GetTypeSymbol(visitor.SymbolTable, visitor.Inferrer, destrnode.Information.Type);
// Create the new symbol for the variable
var boundSymbol = visitor.SymbolTable.AddNewVariableSymbol(variableName, varType, Access.Public, SymbolHelper.GetStorage(destrnode.Information.Mutability));
if (varType is Anonymous asym)
{
visitor.Inferrer.TrackSymbol(asym, boundSymbol);
}
}
}
protected IType VarDestructuringNode(TypeInferrerVisitor visitor, VariableDestructuringNode destructuringNode)
{
var rhsTupleType = destructuringNode.Right.Visit(visitor) as Tuple;
for (int i = 0; i < destructuringNode.Left.Count; i++)
{
var declaration = destructuringNode.Left[i];
if (declaration == null)
{
continue;
}
// Symbol should be already resolved here
var lhs = visitor.SymbolTable.GetVariableSymbol(declaration.Value);
// If it is a variable definition, get the right-hand side type info
var rhsType = rhsTupleType.Elements[i];
// Check types to see if we can unify them
var generalType = visitor.Inferrer.FindMostGeneralType(lhs.TypeSymbol, rhsType is IType rts ? rts : (rhsType as IVariable).TypeSymbol);
visitor.Inferrer.Unify(visitor.SymbolTable, generalType, lhs as IVariable);
}
return(rhsTupleType);
}
protected Operand VarDestructuringNode(ILGenerator generator, VariableDestructuringNode vardestnode)
{
// Get the variable type
//TypeResolver typeresolver = TypeResolver.GetTypeResolverFromToken(vardestnode.VarType.TypeToken);
/*vardestnode.DestructInit.Exec()
*
* foreach (var declaration in vardestnode.VarDefinitions)
* {
* var identifierToken = declaration.Item1;
* var initializerInstr = declaration.Item2?.Exec(generator);
*
* generator.Emmit(new LocalVarInstruction(dataType, identifierToken.Value.ToString(), initializerInstr?.TargetName));
* }*/
return(null);
}
protected MutabilityCheckResult VarDestructuringNode(MutabilityCheckerVisitor checker, VariableDestructuringNode vardestnode)
{
vardestnode.Right.Visit(checker);
return(null);
}
