private static TypeReference LiftGenericTypeDefinition(TypeDefinition node)
{
var typeRef = new GenericTypeReference(node.LexicalInfo, node.QualifiedName);
foreach (GenericParameterDeclaration parameter in node.GenericParameters)
typeRef.GenericArguments.Add(Lift(parameter.Name));
return typeRef;
}
private void EnterTypeDefinition(AST.TypeDefinition node, ClassType classType)
{
//LoggingService.Debug("Enter " + node.GetType().Name + " (" + node.FullName + ")");
foreach (AST.Attribute att in node.Attributes)
{
if (att.Name == "Boo.Lang.ModuleAttribute")
{
classType = ClassType.Module;
}
}
DomRegion region = GetClientRegion(node);
DefaultClass c = new DefaultClass(_cu, classType, GetModifier(node), region, OuterClass);
c.FullyQualifiedName = node.FullName;
if (_currentClass.Count > 0)
{
_currentClass.Peek().InnerClasses.Add(c);
}
else
{
_cu.Classes.Add(c);
}
_currentClass.Push(c);
ConvertAttributes(node, c);
ConvertTemplates(node, c);
if (node.BaseTypes != null)
{
foreach (AST.TypeReference r in node.BaseTypes)
{
c.BaseTypes.Add(CreateReturnType(r));
}
}
}
void LeaveTypeDefinition(TypeDefinition node)
{
if (!node.IsVisibilitySet)
node.Modifiers |= Context.Parameters.DefaultTypeVisibility;
node.Name = NormalizeName(node.Name);
}
private void OnCandidatePartialDefinition(TypeDefinition node)
{
if (!node.IsPartial)
return;
var typeName = node.FullName;
TypeDefinition originalDefinition;
if (_partials.TryGetValue(typeName, out originalDefinition))
{
if (node == originalDefinition) // MergePartialTypes can be executed more than once
return;
if (originalDefinition.NodeType != node.NodeType)
{
Errors.Add(CompilerErrorFactory.IncompatiblePartialDefinition(node, typeName, AstUtil.TypeKeywordFor(originalDefinition), AstUtil.TypeKeywordFor(node)));
return;
}
MergeImports(node, originalDefinition);
originalDefinition.Merge(node);
RemoveCurrentNode();
}
else
_partials[typeName] = node;
}
//use this to build a type member name unique in the inheritance hierarchy.
public static string BuildUniqueTypeMemberName(TypeDefinition type, string name)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentNullException("name");
StringBuilder nameBuilder = new StringBuilder("$");
nameBuilder.Append(name);
nameBuilder.Append("__");
nameBuilder.Append(type.QualifiedName);
if (type.HasGenericParameters)
{
nameBuilder.Append("_");
string[] parameterNames = Array.ConvertAll<GenericParameterDeclaration, string>(
type.GenericParameters.ToArray(),
delegate(GenericParameterDeclaration gpd) { return gpd.Name; });
foreach (string parameterName in parameterNames)
{
nameBuilder.Append("_");
nameBuilder.Append(parameterName);
}
}
nameBuilder.Replace('.', '_');
nameBuilder.Append("$");
return nameBuilder.ToString();
}
void EnterTypeDefinition(TypeDefinition node)
{
List<Field> list = new List<Field>();
fieldStack.Push(list);
foreach (TypeMember member in node.Members) {
if (member is Field)
list.Add((Field)member);
}
}
public static void BindMembers(string cacheName,TypeDefinition type){
if (!cache.ContainsKey(cacheName)) return;
foreach (var member in cache[cacheName]){
type.Members.Add(member);
}
cache.Remove(cacheName);
new Method().Parameters.Add(new ParameterDeclaration("name",new SimpleTypeReference("string")));
}
private void OnTypeDefinition(TypeDefinition node)
{
var old = _currentType;
_currentType = (IType)node.Entity;
Visit(node.Attributes);
Visit(node.BaseTypes);
Visit(node.Members);
Visit(node.GenericParameters);
_currentType = old;
}
protected override void ExtendBaseClass(TypeDefinition definition)
{
Property property = new Property("Environment");
property.Getter = new Method("getter_Environment");
property.Getter.Body.Add(
new ReturnStatement(
new StringLiteralExpression(environment ?? "")
)
);
definition.Members.Add(property);
}
public InternalGenericParameter(TypeSystemServices tss, GenericParameterDeclaration declaration)
{
_tss = tss;
_declaration = declaration;
// Determine and remember declaring type and declaring method (if applicable)
_declaringMethod = declaration.ParentNode as Method;
_declaringType = (
_declaringMethod == null ?
declaration.ParentNode as TypeDefinition : _declaringMethod.DeclaringType);
}
void CheckMembers(TypeDefinition node)
{
_members.Clear();
foreach (TypeMember member in node.Members)
{
if (member.NodeType == NodeType.StatementTypeMember)
continue;
var list = GetMemberList(member.Name);
CheckMember(list, member);
list.Add(member);
}
}
static void MergeImports(TypeDefinition from, TypeDefinition to)
{
Module fromModule = from.EnclosingModule;
Module toModule = to.EnclosingModule;
if (fromModule == toModule) return;
if (toModule.ContainsAnnotation(fromModule)) return;
toModule.Imports.ExtendWithClones(fromModule.Imports.Where(i => !toModule.Imports.Any(i2 => i.Matches(i2))));
// annotate so we remember not to merge the imports
// again in the future
toModule.Annotate(fromModule);
//annotate so that we know these modules have been merged
//this is used by checkneverusedmembers step
if (!fromModule.ContainsAnnotation("merged-module"))
fromModule.Annotate("merged-module");
if (!toModule.ContainsAnnotation("merged-module"))
toModule.Annotate("merged-module");
}
override public void LeaveTypeDefinition(TypeDefinition node)
{
_safeVars.Clear(); //clear type var cache (CheckAmbiguousVariableNames)
if (node.NodeType == NodeType.Module)
return;
string qualifiedName = node.QualifiedName;
if (node.HasGenericParameters)
{
qualifiedName += "`" + node.GenericParameters.Count;
}
if (_types.ContainsKey(qualifiedName))
{
Errors.Add(CompilerErrorFactory.NamespaceAlreadyContainsMember(node, GetNamespace(node), node.Name));
return;
}
_types.Add(qualifiedName, node);
}
public BaseTypeResolution(CompilerContext context, TypeDefinition typeDefinition, List<TypeDefinition> visited) : base(context)
{
_typeDefinition = typeDefinition;
_visited = visited;
_visited.Add(_typeDefinition);
_removed = 0;
_index = -1;
NameResolutionService nameResolution = NameResolutionService;
INamespace previous = nameResolution.CurrentNamespace;
nameResolution.EnterNamespace(ParentNamespaceOf(_typeDefinition));
try
{
Run();
}
finally
{
nameResolution.EnterNamespace(previous);
}
}
private void GenerateConstructors(TypeDefinition definition)
{
ConstructorInfo[] ctors =
baseClass.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (ConstructorInfo ctor in ctors)
{
if (ctor.IsPrivate)
continue;
Constructor constructor = new Constructor(definition.LexicalInfo);
definition.Members.Add(constructor);
MethodInvocationExpression super = new MethodInvocationExpression(new SuperLiteralExpression());
constructor.Body.Add(super);
foreach (ParameterInfo info in ctor.GetParameters())
{
SimpleTypeReference typeReference =
new SimpleTypeReference(TypeUtilities.GetFullName(info.ParameterType));
constructor.Parameters.Add(new ParameterDeclaration(info.Name,
typeReference)
);
super.Arguments.Add(new ReferenceExpression(info.Name));
}
}
}
private void LeaveTypeDefinition(AST.TypeDefinition node)
{
DefaultClass c = _currentClass.Pop();
foreach (AST.Attribute att in node.Attributes)
{
if (att.Name == "System.Reflection.DefaultMemberAttribute" && att.Arguments.Count == 1)
{
AST.StringLiteralExpression sle = att.Arguments[0] as AST.StringLiteralExpression;
if (sle != null)
{
foreach (DefaultProperty p in c.Properties)
{
if (p.Name == sle.Value)
{
p.IsIndexer = true;
}
}
}
}
}
//LoggingService.Debug("Leave "+node.GetType().Name+" "+node.FullName+" (Class = "+c.FullyQualifiedName+")");
}
Constructor GetStaticConstructor(TypeDefinition type)
{
return CodeBuilder.GetOrCreateStaticConstructorFor(type);
}
private Method GetInitializerFor(TypeDefinition type, bool isStatic)
{
string methodName = isStatic ? "$static_initializer$" : "$initializer$";
Method method = (Method)type[methodName];
if (null == method)
{
if (isStatic)
{
if (!type.HasStaticConstructor)
{
// when the class doesnt have a static constructor
// yet, create one and use it as the static
// field initializer method
method = CodeBuilder.CreateStaticConstructor(type);
}
else
{
method = CreateInitializerMethod(type, methodName, TypeMemberModifiers.Static);
AddInitializerToStaticConstructor(type, (InternalMethod)method.Entity);
}
}
else
{
method = CreateInitializerMethod(type, methodName, TypeMemberModifiers.None);
}
type[methodName] = method;
}
return method;
}
private Field GetFieldsInitializerInitializedField(TypeDefinition type)
{
string name = AstUtil.BuildUniqueTypeMemberName(type, "initialized");
Field field= (Field) type.Members[name];
if (null == field)
{
field = CodeBuilder.CreateField(name, TypeSystemServices.BoolType);
field.Visibility = TypeMemberModifiers.Private;
type.Members.Add(field);
MarkVisited(field);
}
return field;
}
Method CreateInitializerMethod(TypeDefinition type, string name, TypeMemberModifiers modifiers)
{
Method method = CodeBuilder.CreateMethod(name, TypeSystemServices.VoidType, modifiers);
type.Members.Add(method);
MarkVisited(method);
return method;
}
void AddInitializerToStaticConstructor(TypeDefinition type, InternalMethod initializer)
{
GetStaticConstructor(type).Body.Insert(0,
CodeBuilder.CreateMethodInvocation(initializer));
}
public Constructor CreateStaticConstructor(TypeDefinition type)
{
var constructor = new Constructor();
constructor.IsSynthetic = true;
constructor.Modifiers = TypeMemberModifiers.Private | TypeMemberModifiers.Static;
EnsureEntityFor(constructor);
type.Members.Add(constructor);
return constructor;
}
public static CompilerContext compile_(TypeDefinition klass, params Assembly[] references)
{
return compile_(CreateCompileUnit(klass), references);
}
public static Type compile(TypeDefinition klass, params Assembly[] references)
{
var result = compile_(klass, references);
AssertNoErrors(result);
return result.GeneratedAssembly.GetType(klass.Name);
}
private static Module CreateModule(TypeDefinition klass)
{
Module module = new Module();
module.Name = klass.Name;
module.Members.Add(klass);
return module;
}
private static CompileUnit CreateCompileUnit(TypeDefinition klass)
{
return new CompileUnit(CreateModule(klass));
}
void CantBeMarkedPartialIfNested(TypeDefinition type)
{
if (type.IsNested)
CantBeMarkedPartial(type);
}
public object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
{
if (typeDeclaration.Templates.Count > 0)
{
AddError(typeDeclaration, "Generic type definitions are not supported.");
}
B.TypeDefinition oldType = currentType;
B.TypeDefinition typeDef;
switch (typeDeclaration.Type)
{
case ClassType.Class:
typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
break;
case ClassType.Interface:
typeDef = new B.InterfaceDefinition(GetLexicalInfo(typeDeclaration));
break;
case ClassType.Enum:
typeDef = new B.EnumDefinition(GetLexicalInfo(typeDeclaration));
break;
case ClassType.Struct:
typeDef = new B.StructDefinition(GetLexicalInfo(typeDeclaration));
break;
case ClassType.Module:
typeDef = new B.ClassDefinition(GetLexicalInfo(typeDeclaration));
typeDeclaration.Modifier |= Modifiers.Static;
break;
default:
AddError(typeDeclaration, "Unknown class type.");
return(null);
}
if (currentType != null)
{
typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Private);
}
else
{
typeDef.Modifiers = ConvertModifier(typeDeclaration, B.TypeMemberModifiers.Internal);
}
typeDef.Name = typeDeclaration.Name;
typeDef.EndSourceLocation = GetLocation(typeDeclaration.EndLocation);
ConvertAttributes(typeDeclaration.Attributes, typeDef.Attributes);
ConvertTypeReferences(typeDeclaration.BaseTypes, typeDef.BaseTypes);
if (currentType != null)
{
currentType.Members.Add(typeDef);
}
else
{
module.Members.Add(typeDef);
}
currentType = typeDef;
typeDeclaration.AcceptChildren(this, data);
currentType = oldType;
return(typeDef);
}
private void VisitBaseTypes(TypeDefinition node)
{
foreach (var baseTypeRef in node.BaseTypes)
EnsureRelatedNodeWasVisited(baseTypeRef, baseTypeRef.Entity);
}
private void VisitTypeDefinition(TypeDefinition node)
{
var ns = (INamespace)GetEntity(node);
EnterNamespace(ns);
VisitBaseTypes(node);
Visit(node.Attributes);
Visit(node.Members);
LeaveNamespace();
}
void AddInitializedGuardToInitializer(TypeDefinition type, Method initializer)
{
Field field = GetFieldsInitializerInitializedField(type);
//run initializer code only if $initialized$ is false
//hmm quasi-notation would be lovely here
Block trueBlock = new Block();
trueBlock.Add(new GotoStatement(LexicalInfo.Empty, new ReferenceExpression("___initialized___")));
IfStatement cond = new IfStatement(CodeBuilder.CreateReference(field),
trueBlock, null);
initializer.Body.Insert(0, cond);
//set $initialized$ field to true
initializer.Body.Add(
CodeBuilder.CreateFieldAssignment(field, new BoolLiteralExpression(true)));
//label we're past the initializer
initializer.Body.Add(
new LabelStatement(LexicalInfo.Empty, "___initialized___"));
}
public Constructor GetOrCreateStaticConstructorFor(TypeDefinition type)
{
return type.GetStaticConstructor() ?? CreateStaticConstructor(type);
}
void AddInitializerToInstanceConstructors(TypeDefinition type, Method initializer)
{
int n = 0;
//count number of non-static constructors
foreach (TypeMember node in type.Members)
{
if (NodeType.Constructor == node.NodeType && !node.IsStatic)
n++;
}
//if there is more than one we need $initialized$ guard check
if (n > 1)
AddInitializedGuardToInitializer(type, initializer);
foreach (TypeMember node in type.Members)
{
if (NodeType.Constructor == node.NodeType && !node.IsStatic)
{
Constructor constructor = (Constructor) node;
n = GetIndexAfterSuperInvocation(constructor.Body);
foreach (Statement st in initializer.Body.Statements)
{
constructor.Body.Insert(n, (Statement) st.Clone());
n++;
}
foreach (Local loc in initializer.Locals)
{
constructor.Locals.Add(loc);
}
}
}
}
