public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
base.VisitTypeDefinitionStatement(typeDef);
typeDef.Builder.CreateType();
return(true);
}
public override bool VisitLeave(TypeDefinitionStatement typeDef)
{
if (toProcess.Count != 0)
{
ReProcessTypesOnQueue();
}
return(base.VisitLeave(typeDef));
}
private string BuildTypeName(TypeDefinitionStatement def)
{
if (currentNamespace != null)
{
return(String.Format("{0}.{1}", def.Name));
}
return(def.Name);
}
private void DeclareAndPopulateGlobalSourceUnit(CompilationUnit unit)
{
SourceUnit globalUnit = new SourceUnit(unit, "<global>");
TypeDefinitionStatement globalType = new TypeDefinitionStatement(AccessLevel.Public, "RookGlobal");
globalUnit.Statements.Add(globalType);
MethodDefinitionStatement entryPoint = new MethodDefinitionStatement(AccessLevel.Public);
entryPoint.Name = "self.main";
foreach (SourceUnit sunit in unit.SourceUnits)
{
foreach (IStatement stmt in sunit.Statements)
{
if (stmt.StatementType == StatementType.TypeDefinition)
{
continue;
}
stmt.Parent.RemoveChild(stmt);
if (stmt.StatementType == StatementType.MethodDef)
{
(stmt as MethodDefinitionStatement).IsStatic = true;
}
if (stmt.StatementType == StatementType.MultipleVarDeclaration)
{
// TODO: Ensure no instance vars defined
}
if (stmt.StatementType == StatementType.ExpressionStmt ||
stmt.StatementType == StatementType.MultipleVarDeclaration)
{
entryPoint.Statements.Add(stmt);
}
else
{
globalType.Statements.Add(stmt);
}
}
}
if (entryPoint.Statements.Count != 0)
{
globalType.Statements.Add(entryPoint);
// Might be necessary
// unit.EntryPointMethod = entryPoint;
}
unit.SourceUnits.Add(globalUnit);
}
public virtual bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
if (VisitEnter(typeDef))
{
VisitNodes(typeDef.Statements);
return(VisitLeave(typeDef));
}
return(false);
}
public override bool VisitSourceUnit(SourceUnit unit)
{
NamespaceGraph nsGraph = unit.SymbolTable.TypeGraphView.DefineNamespace("Castle.Rook.Code");
unit.SymbolTable.CurrentNamespace = nsGraph;
TypeDefinitionStatement typeDef = new TypeDefinitionStatement(unit.SymbolTable, AccessLevel.Private, String.Format("Global{0}", globalClassesCount++));
unit.SymbolTable.CurrentTypeDefinition = typeDef.SymbolTable.CurrentNamespace.AddTransientType(typeDef);
return(base.VisitSourceUnit(unit));
}
public TransientType AddTransientType(TypeDefinitionStatement typeDef)
{
if (types.Contains(typeDef.Name))
{
throw new ArgumentNullException("Type " + typeDef.Name + " already exists.");
}
TransientType type = new TransientType(typeDef);
types[typeDef.Name] = type;
return(type);
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
nodeStack.Push(CurrentNode.Nodes.Add("Type " + typeDef.Name + " (" + typeDef.FullName + ")"));
CurrentNode.Tag = typeDef;
CurrentNode.EnsureVisible();
base.VisitTypeDefinitionStatement(typeDef);
nodeStack.Pop();
return(true);
}
public virtual bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
if (VisitEnter(typeDef))
{
// VisitNodes(typeDef.Fields);
// VisitNodes(typeDef.Constructors);
// VisitNodes(typeDef.Methods);
VisitNodes(typeDef.Statements);
return(VisitLeave(typeDef));
}
return(false);
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
typeDef.Name = BuildTypeName(typeDef);
if (ResolveBaseType(typeDef))
{
CreateAndRegisterTypeBuilder(typeDef);
}
else
{
// Enqueue
toProcess.Enqueue(typeDef);
}
base.VisitTypeDefinitionStatement(typeDef);
return(true);
}
private bool ResolveBaseType(TypeDefinitionStatement typeDef)
{
bool weAreHappy = true;
foreach (TypeReference typeRef in typeDef.BaseTypes)
{
if (!resolver.Resolve(typeRef))
{
if (enableErrorReporting)
{
errorReport.Error("TODO:FILENAME", typeDef.Position,
"Could not resolve type {0}. Are you forgetting about " +
"a reference to an assembly?", typeRef.TypeName);
}
weAreHappy = false;
}
}
return(weAreHappy);
}
private bool ReProcessTypesOnQueue()
{
object head = null;
for (;;)
{
if (toProcess.Count == 0)
{
break;
}
TypeDefinitionStatement typeDef = (TypeDefinitionStatement)toProcess.Dequeue();
if (head == null)
{
head = typeDef;
}
else if (typeDef == head)
{
// Back to the first
toProcess.Enqueue(typeDef);
break;
}
if (ResolveBaseType(typeDef))
{
CreateAndRegisterTypeBuilder(typeDef);
}
else
{
toProcess.Enqueue(typeDef);
}
}
return(toProcess.Count == 0);
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
if (!identifierService.IsValidTypeName(typeDef.Name))
{
errorReport.Error("TODOFILENAME", typeDef.Position, "'{0}' is an invalid type name.", typeDef.Name);
return(false);
}
System.Diagnostics.Debug.Assert(typeDef.SymbolTable.CurrentNamespace != null);
typeDef.NamespaceName = typeDef.SymbolTable.CurrentNamespace.Name;
if (typeDef.SymbolTable.CurrentNamespace.GetType(typeDef.Name) != null)
{
errorReport.Error("TODOFILENAME", typeDef.Position, "'{0}' has multiple definitions.", typeDef.Name);
return(false);
}
typeDef.SymbolTable.CurrentTypeDefinition = typeDef.SymbolTable.CurrentNamespace.AddTransientType(typeDef);
return(base.VisitTypeDefinitionStatement(typeDef));
}
public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
{
visitedNodes.Add(typeDef);
return(base.VisitTypeDefinitionStatement(typeDef));
}
public override bool VisitEnter(TypeDefinitionStatement typeDef)
{
nowQueue = true;
return(base.VisitEnter(typeDef));
}
public virtual bool VisitEnter(TypeDefinitionStatement typeDef)
{
return(true);
}
public override bool VisitLeave(TypeDefinitionStatement typeDef)
{
nowQueue = false;
return(base.VisitLeave(typeDef));
}
public TransientType(TypeDefinitionStatement typeDef)
{
this.typeDef = typeDef;
}
public void AssignConvertedToDeclaration4()
{
String contents =
"namespace Family::Guy \r\n"+
" \r\n"+
" class Boat \r\n"+
" \r\n"+
" def initialize \r\n"+
" @x = 1 \r\n"+
" end \r\n"+
" \r\n"+
" end \r\n"+
" \r\n"+
" class Song \r\n"+
" \r\n"+
" def save \r\n"+
" @name = 1 \r\n"+
" end \r\n"+
" \r\n"+
" end \r\n"+
" \r\n"+
"end \r\n"+
"";
SourceUnit unit = container.ParserService.Parse(contents);
AssertNoErrorOrWarnings();
Assert.IsNotNull(unit);
DeclarationBinding sb = container[typeof(DeclarationBinding)] as DeclarationBinding;
sb.ExecutePass(unit.CompilationUnit);
AssertNoErrorOrWarnings();
Assert.AreEqual(1, unit.Namespaces.Count);
NamespaceDeclaration nsDecl = unit.Namespaces[0] as NamespaceDeclaration;
Assert.AreEqual(2, nsDecl.TypeDeclarations.Count);
TypeDefinitionStatement boatType = nsDecl.TypeDeclarations[0] as TypeDefinitionStatement;
TypeDefinitionStatement songType = nsDecl.TypeDeclarations[1] as TypeDefinitionStatement;
Assert.AreEqual(2, boatType.Statements.Count);
Assert.AreEqual(2, songType.Statements.Count);
MethodDefinitionStatement initMethod = boatType.Statements[0] as MethodDefinitionStatement;
SingleVariableDeclarationStatement boatVarDecl = boatType.Statements[1] as SingleVariableDeclarationStatement;
MethodDefinitionStatement saveMethod = songType.Statements[0] as MethodDefinitionStatement;
SingleVariableDeclarationStatement songVarDecl = songType.Statements[1] as SingleVariableDeclarationStatement;
Assert.AreEqual(1, initMethod.Statements.Count);
Assert.AreEqual(1, saveMethod.Statements.Count);
ExpressionStatement assignStmt1 = initMethod.Statements[0] as ExpressionStatement;
ExpressionStatement assignStmt2 = saveMethod.Statements[0] as ExpressionStatement;
Assert.IsNotNull(assignStmt1);
Assert.IsNotNull(assignStmt2);
AssignmentExpression assignExp1 = assignStmt1.Expression as AssignmentExpression;
AssignmentExpression assignExp2 = assignStmt2.Expression as AssignmentExpression;
Assert.IsNotNull(assignExp1);
Assert.IsNotNull(assignExp2);
Assert.AreEqual("@x", (assignExp1.Target as VariableReferenceExpression).Identifier.Name);
Assert.AreEqual("1", (assignExp1.Value as LiteralReferenceExpression).Content);
Assert.AreEqual("@name", (assignExp2.Target as VariableReferenceExpression).Identifier.Name);
Assert.AreEqual("1", (assignExp2.Value as LiteralReferenceExpression).Content);
}
private void CreateAndRegisterTypeBuilder(TypeDefinitionStatement typeDef)
{
Type baseType = null;
IList interfaces = new ArrayList();
foreach (TypeReference typeRef in typeDef.BaseTypes)
{
if (typeRef.ResolvedType.IsClass)
{
if (baseType != null)
{
// Hey we do not support multiple inheritance
errorReport.Error(
currentFileName,
typeDef.Position,
"We do not support multiple inheritance.. at least yet");
return;
}
else
{
baseType = typeRef.ResolvedType;
}
}
else if (typeRef.ResolvedType.IsInterface)
{
interfaces.Add(typeRef.ResolvedType);
}
else
{
errorReport.Error(
currentFileName,
typeDef.Position,
"You're trying to extend from a type that is neither a class nor interface");
return;
}
}
TypeBuilder typeBuilder = null;
if (baseType == null)
{
typeBuilder = modBuilder.DefineType(typeDef.Name,
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Serializable);
}
else
{
typeBuilder = modBuilder.DefineType(typeDef.Name,
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Serializable, baseType);
}
typeDef.ParentType = baseType != null ? baseType : typeof(Object);
foreach (Type interfaceType in interfaces)
{
typeBuilder.AddInterfaceImplementation(interfaceType);
typeDef.Interfaces.Add(interfaceType);
}
typeDef.Builder = typeBuilder;
if (typeBuilder.Namespace == null || typeBuilder.Namespace == String.Empty)
{
container.AddUserType(typeBuilder);
}
else
{
container.GetNamespace(typeBuilder.Namespace).AddUserType(typeBuilder);
}
}
