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); }