public AssignmentExpressionSyntax(TokenSyntax identifierToken, TypeDefinitionSyntax definition, TokenSyntax operatorToken, ExpressionSyntax expression)
{
IdentifierToken = identifierToken;
Definition = definition;
OperatorToken = operatorToken;
Expression = expression;
}
private void TryPolyStruct(TypeDefinitionSyntax pNode, StructInitializerSyntax pInitializer)
{
//Number of generic type parameters on the type does not match
//the number of type arguments specified at the initialization site
if (pInitializer.Struct.GenericArguments.Count != pNode.TypeParameters.Count)
{
CompilerErrors.TypePolyArgumentCount(pInitializer.Struct, pNode.TypeParameters.Count, pInitializer.Span);
}
//We just create a dictionary of T,int; T2,string; etc... and feed that to the type
//When the type is emitted it will create a copy of itself for each unique generic argument
Dictionary <string, SmallType> types = new Dictionary <string, SmallType>();
for (int i = 0; i < pNode.TypeParameters.Count; i++)
{
types.Add(pNode.TypeParameters[i], pInitializer.Struct.GenericArguments[i].Type);
}
pNode.AddTypeMapping(types);
//We also need to add the same type mappings for any trait implementations
var name = SyntaxHelper.GetFullTypeName(pNode.GetApplicableType());
if (_implements.ContainsKey(name))
{
foreach (var impl in _implements[name])
{
impl.AddTypeMapping(types);
}
}
}
protected override void VisitTypeDefinitionSyntax(TypeDefinitionSyntax pNode)
{
if (pNode.DefinitionType != DefinitionTypes.Implement && pNode.DeclaredType.Namespace != null)
{
CompilerErrors.StructNamespace(pNode.Span);
}
base.VisitTypeDefinitionSyntax(pNode);
}
public void AddNode(TypeDefinitionSyntax pNode)
{
var name = SyntaxHelper.GetFullTypeName(pNode.GetApplicableType());
var idx = _structs.Count;
_structIndex.Add(name, idx);
_structs.Add(new DiscoveryNode(pNode));
}
public void Render(TypeDefinitionSyntax typeDefinition)
{
Render(typeDefinition.TypeKeywordNode);
WriteSpace();
Render(typeDefinition.NewTypeNameNode);
WriteSpace();
Render(typeDefinition.ExtendsKeywordNode);
WriteSpace();
Render(typeDefinition.BaseTypeNode);
}
private BoundType BindTypeDefinition(TypeDefinitionSyntax syntax, Symbol parent)
{
switch (syntax.Kind)
{
case SyntaxKind.ClassType:
case SyntaxKind.StructType:
return(BindStructDeclaration((StructTypeSyntax)syntax, parent));
case SyntaxKind.InterfaceType:
return(BindInterfaceDeclaration((InterfaceTypeSyntax)syntax, parent));
default:
throw new ArgumentOutOfRangeException();
}
}
protected virtual void VisitTypeDefinitionSyntax(TypeDefinitionSyntax pNode)
{
Visit(pNode.DeclaredType);
Visit(pNode.AppliesTo);
using (var s = Store.AddValue("__Struct", pNode.GetApplicableType().Type))
{
for (int i = 0; i < pNode.Fields.Count; i++)
{
Visit(pNode.Fields[i]);
}
foreach (var m in pNode.Methods)
{
Visit(m);
}
}
}
protected virtual SyntaxNode VisitTypeDefinitionSyntax(TypeDefinitionSyntax pNode)
{
List <TypedIdentifierSyntax> fields = new List <TypedIdentifierSyntax>(pNode.Fields.Count);
List <MethodSyntax> methods = new List <MethodSyntax>(pNode.Methods.Count);
for (int i = 0; i < pNode.Fields.Count; i++)
{
fields.Add((TypedIdentifierSyntax)Visit(pNode.Fields[i]));
}
foreach (var m in pNode.Methods)
{
methods.Add((MethodSyntax)Visit(m));
}
return(SyntaxFactory.TypeDefinition(pNode.Scope, (TypeSyntax)Visit(pNode.DeclaredType), (TypeSyntax)Visit(pNode.AppliesTo), pNode.DefinitionType, methods, fields));
}
private void MaybeQueueStructToPoly(TypeDefinitionSyntax pType)
{
//Find all implementations and generic structs
//We will need to know this so we can poly implements of the types
if (pType.DefinitionType == DefinitionTypes.Implement)
{
var applies = SyntaxHelper.GetFullTypeName(pType.AppliesTo);
if (!_implements.ContainsKey(applies))
{
_implements.Add(applies, new List <TypeDefinitionSyntax>());
}
_implements[applies].Add(pType);
}
else if (pType.TypeParameters.Count > 0)
{
//This is a generic type, put it in the queue to be poly'd
_structsToPoly.Add(pType.Name, pType);
}
}
public FunctionDeclarationSyntax(
TokenSyntax keywToken,
TokenSyntax identifier,
TokenSyntax leftParenthesis,
SeperatedSyntaxList <TypedIdentifierSyntax> parameters,
TokenSyntax rightParenthesis,
TypeDefinitionSyntax returnType,
StatementSyntax body,
string implicitLabel
)
{
KeywToken = keywToken;
Identifier = identifier;
LeftParenthesis = leftParenthesis;
Parameters = parameters;
RightParenthesis = rightParenthesis;
ReturnType = returnType;
Body = body;
ImplicitLabel = implicitLabel;
}
private void ValidateImplementation(TypeDefinitionSyntax pTrait, TypeDefinitionSyntax pImplement)
{
//Ensure that all fields are in the implementation
foreach (var tf in pTrait.Fields)
{
bool found = false;
foreach (var f in pImplement.Fields)
{
if (tf.Value == f.Value)
{
found = true;
break;
}
}
if (!found)
{
CompilerErrors.ImplementationMissingField(tf.Value, pTrait, pImplement.Span);
}
}
//Ensure that all methods are in the implementation
foreach (var tm in pTrait.Methods)
{
bool found = false;
foreach (var im in pImplement.Methods)
{
if (im.Name == tm.Name && im.Parameters.Count == tm.Parameters.Count)
{
found = true;
break;
}
}
if (!found)
{
CompilerErrors.ImplementationMissingMethod(tm.Name, pTrait, pImplement.Span);
}
}
}
protected override SyntaxNode VisitTypeDefinitionSyntax(TypeDefinitionSyntax pNode)
{
if (pNode.TypeParameters.Count == 0)
{
return(base.VisitTypeDefinitionSyntax(pNode));
}
_currentType = SyntaxHelper.GetFullTypeName(pNode.GetApplicableType());
//Create our generic parameter types
_types.Clear();
foreach (var t in pNode.TypeParameters)
{
var T = SmallTypeCache.CreateGenericParameter(t);
var arrT = SmallTypeCache.CreateGenericParameter(SmallTypeCache.GetArrayType(T), T);
_types.Add(T.Name, SyntaxFactory.GenericType(T));
_types.Add(arrT.Name, SyntaxFactory.GenericType(arrT));
}
//Update any field identifier types to use the generic parameter type
List <TypedIdentifierSyntax> fields = new List <TypedIdentifierSyntax>(pNode.Fields.Count);
for (int i = 0; i < pNode.Fields.Count; i++)
{
var type = PolyType(pNode.Fields[i].TypeNode);
var iden = pNode.Fields[i].Value;
fields.Add(SyntaxFactory.TypedIdentifier(type, iden));
}
//Update any trait field identifier types to use the generic parameter types
if (_implements.ContainsKey(_currentType))
{
foreach (var trait in _implements[_currentType])
{
foreach (var field in trait.Fields)
{
var type = PolyType(field.TypeNode);
var iden = field.Value;
fields.Add(SyntaxFactory.TypedIdentifier(type, iden));
}
}
}
//Ensure all methods are using the new generic parameter types
List <MethodSyntax> methods = new List <MethodSyntax>(pNode.Methods.Count);
foreach (var m in pNode.Methods)
{
methods.Add((MethodSyntax)Visit(m));
}
//Poly the type it applies to use the generic type
var appliesTo = pNode.AppliesTo;
if (appliesTo != null)
{
appliesTo = PolyType(pNode.AppliesTo);
}
_currentType = null;
return(SyntaxFactory.TypeDefinition(pNode.Scope, pNode.DeclaredType, appliesTo, pNode.DefinitionType, methods, fields));
}
public DiscoveryNode(TypeDefinitionSyntax pNode)
{
Node = pNode;
Permanent = false;
Temporary = false;
}
private bool AddType(TypeDefinitionSyntax pDefinition)
{
//Check for duplicate type definitions
pDefinition.EmitOrder = _order++;
var name = SyntaxHelper.GetFullTypeName(pDefinition.DeclaredType);
if (_unit.IsTypeDefined(name))
{
CompilerErrors.DuplicateType(name, pDefinition.Span);
return(true);
}
//Ensure types on base struct
for (int i = 0; i < pDefinition.Fields.Count; i++)
{
//Ensure all types on the field have been found
var f = pDefinition.Fields[i];
var typeName = SyntaxHelper.GetFullTypeName(f.TypeNode);
if (!pDefinition.TypeParameters.Contains(typeName))
{
var result = _unit.FromString(f.TypeNode, out SmallType fieldType);
if (result != Compiler.FindResult.Found)
{
return(false);
}
f.TypeNode.SetType(fieldType);
}
}
//Ensure types on any implements
List <TypeDefinitionSyntax> implements = null;
if (_implements.ContainsKey(pDefinition.Name))
{
implements = _implements[pDefinition.Name];
foreach (var impl in implements)
{
for (int i = 0; i < impl.Fields.Count; i++)
{
//Ensure all types on the field have been found
var f = impl.Fields[i];
var typeName = SyntaxHelper.GetFullTypeName(f.TypeNode);
if (!pDefinition.TypeParameters.Contains(typeName))
{
var result = _unit.FromString(f.TypeNode, out SmallType fieldType);
if (result != Compiler.FindResult.Found)
{
return(false);
}
f.TypeNode.SetType(fieldType);
}
}
}
}
//Duplicate fields get checked in AddType
//Other validate like ensuring fields/methods are present is done later after all types have been found
//See ValidateImplementation
_unit.AddType(pDefinition, implements);
return(true);
}
public void AddType(TypeDefinitionSyntax pType, List <TypeDefinitionSyntax> pImplements)
{
_types.AddType(Namespace, pType, pImplements);
}
