private BlockSymbol GetParentBlockSymbol(ASTNode node)
{
node = node.ParentNode;
switch (node)
{
case FileNode _:
return(null);
case ClassDefinitionNode classDefinitionNode:
return((BlockSymbol)classDefinitionNode.Symbol);
default:
DeclarationNode parentBlockNode = GetParentBlockNode(node);
switch (parentBlockNode)
{
case PrototypeDefinitionNode prototypeDefinitionNode:
return((BlockSymbol)prototypeDefinitionNode.Symbol);
case InstanceDefinitionNode instanceDefinitionNode:
return((BlockSymbol)instanceDefinitionNode.Symbol);
case FunctionDefinitionNode functionDefinitionNode:
return((BlockSymbol)functionDefinitionNode.Symbol);
default:
throw new Exception();
}
}
}
private Symbol Resolve(SubclassSymbol subclassSymbol)
{
SubclassNode symbolNode = (SubclassNode)subclassSymbol.Node;
InheritanceParentReferenceNode parentReferenceNode = symbolNode.InheritanceParentReferenceNode;
if (_resolvedSymbolsCurrentIteration.Contains(subclassSymbol))
{
parentReferenceNode.Annotations.Add(new InfiniteInheritanceReferenceLoopError());
return(null);
}
if (_resolvedSymbols.Contains(subclassSymbol))
{
return(subclassSymbol.BaseClassSymbol);
}
_resolvedSymbolsCurrentIteration.Add(subclassSymbol);
_resolvedSymbols.Add(subclassSymbol);
if (parentReferenceNode.PartNodes.Count > 0)
{
// TODO it's impossible scenario for current grammar
parentReferenceNode.Annotations.Add(new NotClassOrPrototypeReferenceError());
return(null);
}
parentReferenceNode.Symbol = GetSymbol(parentReferenceNode.Name);
switch (parentReferenceNode.Symbol)
{
case null:
parentReferenceNode.Annotations.Add(new UndeclaredIdentifierError(parentReferenceNode.Name));
break;
case SubclassSymbol parentSubclassSymbol:
subclassSymbol.InheritanceParentSymbol = parentSubclassSymbol;
subclassSymbol.BaseClassSymbol = (ClassSymbol)Resolve(parentSubclassSymbol);
break;
case ClassSymbol classSymbol:
subclassSymbol.InheritanceParentSymbol = classSymbol;
subclassSymbol.BaseClassSymbol = classSymbol;
break;
default:
parentReferenceNode.Annotations.Add(new NotClassOrPrototypeReferenceError());
break;
}
if (parentReferenceNode.Symbol != null)
{
DeclarationNode declarationNode = (DeclarationNode)parentReferenceNode.Symbol.Node;
declarationNode.Usages.Add(parentReferenceNode);
}
return(subclassSymbol.BaseClassSymbol);
}
private void Resolve(ITypedSymbol typedSymbol)
{
Symbol symbol = (Symbol)typedSymbol;
SymbolType symbolBuiltinType = symbol.BuiltinType;
DeclarationNode typedSymbolNode = (DeclarationNode)symbol.Node;
CustomTypeDeclarationNode customTypeDeclarationNode = (CustomTypeDeclarationNode)typedSymbolNode;
if (symbolBuiltinType == SymbolType.Uninitialized) // if symbolBuiltinType isn't one of the simple builtin types
{
// TODO think of: differentiate NotAClassError and UnknownTypeNameError
if (_symbolTable.ContainsKey(typedSymbol.TypeName))
{
Symbol typeSymbol = _symbolTable[typedSymbol.TypeName];
if (typeSymbol is ClassSymbol)
{
typedSymbol.ComplexType = typeSymbol;
symbol.BuiltinType = SymbolType.Instance;
symbolBuiltinType = SymbolType.Instance;
DeclarationNode declarationNode = (DeclarationNode)typeSymbol.Node;
declarationNode.Usages.Add(customTypeDeclarationNode.TypeNameNode);
}
else
{
typedSymbolNode.Annotations.Add(new UnknownTypeNameError(customTypeDeclarationNode.TypeNameNode.Value, customTypeDeclarationNode.TypeNameNode.Location));
return;
}
}
else
{
typedSymbolNode.Annotations.Add(new UnknownTypeNameError(customTypeDeclarationNode.TypeNameNode.Value, customTypeDeclarationNode.TypeNameNode.Location));
return;
}
}
switch (typedSymbol)
{
case FunctionSymbol _:
switch (symbolBuiltinType)
{
case SymbolType.Class:
case SymbolType.Prototype:
case SymbolType.Func:
symbol.BuiltinType = SymbolType.Uninitialized;
typedSymbolNode.Annotations.Add(new UnsupportedFunctionTypeError(customTypeDeclarationNode.TypeNameNode.Location));
return;
}
break;
case IArraySymbol _:
switch (symbolBuiltinType)
{
case SymbolType.Int:
case SymbolType.String:
case SymbolType.Func:
case SymbolType.Float: // very limited type
break;
default:
symbol.BuiltinType = SymbolType.Uninitialized;
typedSymbolNode.Annotations.Add(new UnsupportedArrayTypeError(customTypeDeclarationNode.TypeNameNode.Location));
return;
}
break;
case NestableSymbol _:
switch (symbolBuiltinType)
{
case SymbolType.Class:
case SymbolType.Prototype:
case SymbolType.Void:
symbol.BuiltinType = SymbolType.Uninitialized;
typedSymbolNode.Annotations.Add(new UnsupportedTypeError(customTypeDeclarationNode.TypeNameNode.Location));
return;
}
break;
}
}
