private void CheckFieldInvocations()
{
var invocations = ContextAnnotations.GetFieldInvocations();
if (invocations == null)
{
return;
}
foreach (var node in invocations)
{
var et = node.Target.ExpressionType;
if (et is AnonymousCallableType)
{
et = ((AnonymousCallableType)et).ConcreteType;
node.Target.ExpressionType = et;
}
var invoke = NameResolutionService.Resolve(et, "Invoke") as IMethod;
if (invoke == null)
{
throw new System.NotSupportedException("Invoke method on callable field not found");
}
node.Target = CodeBuilder.CreateMemberReference(node.Target.LexicalInfo, node.Target, invoke);
}
}
private void BindAllParameters()
{
Method entryPoint = ContextAnnotations.GetEntryPoint(Context);
foreach (INodeWithParameters node in _parameters)
{
var member = (TypeMember)node;
if (member.ContainsAnnotation(PrivateMemberNeverUsed))
{
continue;
}
NameResolutionService.EnterNamespace((INamespace)TypeSystemServices.GetEntity(member.DeclaringType));
CodeBuilder.BindParameterDeclarations(member.IsStatic, node);
if (!member.IsVisible && !member.IsSynthetic)
{
IExplicitMember explicitMember = member as IExplicitMember;
if (null != explicitMember && null != explicitMember.ExplicitInfo)
{
continue;
}
if (member == entryPoint) //private Main is fine
{
continue;
}
member.Annotate(PrivateMemberNeverUsed, null);
}
}
}
override public void Run()
{
if (_context.Errors.Count > 0)
{
return;
}
AssemblyBuilder builder = ContextAnnotations.GetAssemblyBuilder(Context);
builder.Save(Path.GetFileName(Context.GeneratedAssemblyFileName));
}
override public void Run()
{
if (Errors.Count > 0)
{
return;
}
var builder = ContextAnnotations.GetAssemblyBuilder(Context);
var filename = Path.GetFileName(Context.GeneratedAssemblyFileName);
Save(builder, filename);
}
public override void LeaveMethod(Method method)
{
if (ContextAnnotations.IsAsync(method))
{
var entity = (InternalMethod)method.Entity;
var processor = new AsyncMethodProcessor(Context, entity);
processor.Run();
}
else
{
base.LeaveMethod(method);
}
}
private void SetEntryPointIfNecessary(Method entryPoint)
{
if (null == entryPoint)
{
return;
}
if (Parameters.OutputType == CompilerOutputType.Library)
{
return;
}
ContextAnnotations.SetEntryPoint(Context, entryPoint);
}
private void CheckEntryPoint()
{
Method method = ContextAnnotations.GetEntryPoint(Context);
if (null == method)
{
return;
}
IMethod entity = (IMethod)TypeSystemServices.GetEntity(method);
if (IsValidEntryPointReturnType(entity.ReturnType) && IsValidEntryPointParameterList(entity.GetParameters()))
{
return;
}
Errors.Add(CompilerErrorFactory.InvalidEntryPoint(method));
}
private void DetectEntryPoint(Module module, ClassDefinition moduleClass)
{
var entryPoint = module.Globals.IsEmpty
? moduleClass.Members[EntryPointMethodName] as Method
: TransformModuleGlobalsIntoEntryPoint(module, moduleClass);
if (entryPoint == null)
{
return;
}
if (Parameters.OutputType == CompilerOutputType.Library)
{
return;
}
ContextAnnotations.SetEntryPoint(Context, entryPoint);
}
override public void Run()
{
if (Errors.Count > 0)
{
return;
}
var builder = ContextAnnotations.GetAssemblyBuilder(Context);
var filename = Path.GetFileName(Context.GeneratedAssemblyFileName);
Save(builder, filename);
var resFilename = (string)Context.Properties["ResFileName"];
if (resFilename != null)
{
File.Delete(resFilename);
}
}
override public void OnGotoStatement(GotoStatement node)
{
LabelStatement target = ((InternalLabel)node.Label.Entity).LabelStatement;
int gotoDepth = ContextAnnotations.GetTryBlockDepth(node);
int targetDepth = ContextAnnotations.GetTryBlockDepth(target);
if (gotoDepth < targetDepth)
{
BranchError(node, target);
}
else if (gotoDepth == targetDepth)
{
Node gotoParent = AstUtil.GetParentTryExceptEnsure(node);
Node labelParent = AstUtil.GetParentTryExceptEnsure(target);
if (gotoParent != labelParent)
{
BranchError(node, target);
}
}
}
override public void OnModule(Module node)
{
bool hasModuleClass = true;
ClassDefinition moduleClass = FindModuleClass(node);
if (null == moduleClass)
{
moduleClass = new ClassDefinition();
moduleClass.IsSynthetic = true;
hasModuleClass = false;
}
Method entryPoint = moduleClass.Members["Main"] as Method;
int removed = 0;
TypeMember[] members = node.Members.ToArray();
for (int i = 0; i < members.Length; ++i)
{
TypeMember member = members[i];
if (member is TypeDefinition)
{
continue;
}
if (member.NodeType == NodeType.Method)
{
if (EntryPointMethodName == member.Name)
{
entryPoint = (Method)member;
}
member.Modifiers |= TypeMemberModifiers.Static;
}
node.Members.RemoveAt(i - removed);
moduleClass.Members.Add(member);
++removed;
}
if (node.Globals.Statements.Count > 0)
{
Method method = new Method(node.Globals.LexicalInfo);
method.IsSynthetic = true;
method.Parameters.Add(new ParameterDeclaration("argv", new ArrayTypeReference(new SimpleTypeReference("string"))));
method.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType);
method.Body = node.Globals;
method.Name = EntryPointMethodName;
method.Modifiers = TypeMemberModifiers.Static | TypeMemberModifiers.Private;
moduleClass.Members.Add(method);
node.Globals = null;
entryPoint = method;
}
if (null != entryPoint)
{
ContextAnnotations.SetEntryPoint(Context, entryPoint);
}
if (hasModuleClass || _forceModuleClass || (moduleClass.Members.Count > 0))
{
if (!hasModuleClass)
{
moduleClass.Name = BuildModuleClassName(node);
moduleClass.Attributes.Add(CreateBooModuleAttribute());
node.Members.Add(moduleClass);
}
moduleClass.Members.Add(AstUtil.CreateConstructor(node, TypeMemberModifiers.Private));
moduleClass.Modifiers = TypeMemberModifiers.Public |
TypeMemberModifiers.Final |
TypeMemberModifiers.Transient;
((ModuleEntity)node.Entity).InitializeModuleClass(moduleClass);
}
}
private bool HasEntryPoint()
{
return(ContextAnnotations.GetEntryPoint(Context) != null);
}
