B.ExplicitMemberInfo ConvertInterfaceImplementations(List<InterfaceImplementation> implementations, AttributedNode node, B.TypeMember targetMember) { if (implementations.Count == 0) return null; if (implementations.Count > 1) { AddError(node, "Multiple explicit interface implementations are not supported"); } if (implementations[0].MemberName != targetMember.Name) { AddError(node, "Explicit interface implementation: Implementing member with different name is not supported"); } if (targetMember.Modifiers == B.TypeMemberModifiers.Private) { targetMember.Modifiers = B.TypeMemberModifiers.None; } else { AddError(node, "Explicit interface implementation: Only private methods can explicitly implement interfaces"); } B.TypeReference tr = ConvertTypeReference(implementations[0].InterfaceType); if (tr is B.SimpleTypeReference) { B.ExplicitMemberInfo explicitInfo = new B.ExplicitMemberInfo(GetLexicalInfo(node)); explicitInfo.InterfaceType = (B.SimpleTypeReference)tr; return explicitInfo; } else { AddError(node, "Explicit interface implementation: invalid base type, expecting SimpleTypeReference"); return null; } }
private ModifierEnum GetModifier(AST.TypeMember m) { ModifierEnum r = ModifierEnum.None; if (m.IsPublic) r |= ModifierEnum.Public; if (m.IsProtected) r |= ModifierEnum.Protected; if (m.IsPrivate) r |= ModifierEnum.Private; if (m.IsInternal) r |= ModifierEnum.Internal; if (!m.IsVisibilitySet) { if (IsStrictMode(_cu.ProjectContent)) r |= ModifierEnum.Private; else if (m is AST.Field) r |= ModifierEnum.Protected; else r |= ModifierEnum.Public; } if (m.IsStatic) r |= ModifierEnum.Static; if (m is AST.Field) { if (m.IsFinal) r |= ModifierEnum.Readonly; } else { if (m.IsFinal) r |= ModifierEnum.Sealed; } if (m.IsAbstract) r |= ModifierEnum.Abstract; if (m.IsOverride) r |= ModifierEnum.Override; if (m.IsSynthetic) r |= ModifierEnum.Synthetic; if (m.IsPartial) r |= ModifierEnum.Partial; if (m.LexicalInfo.IsValid && m.DeclaringType != null && m.LexicalInfo.Line < m.DeclaringType.LexicalInfo.Line) { // member added through attribute r |= ModifierEnum.Synthetic; } return r; }
void ConvertExpressions(IEnumerable input, B.ExpressionCollection output) { foreach (Expression e in input) { B.Expression expr = ConvertExpression(e); if (expr != null) { output.Add(expr); } } }
public override void OnModule(Module node) { var imports = new[] { "UnityEngine", "System.Collections" }; foreach (var importName in imports) { var targetImport = new Import(LexicalInfo.Empty, importName); if (node.Imports.Contains(targetImport)) node.Imports.Add(targetImport); } }
void AddToBlock(Statement n, B.Block b) { object result = ConvertStatementInternal(n); if (result is ArrayList) { foreach (B.Statement stmt in (ArrayList)result) { b.Add(stmt); } } else { B.Statement stmt = (B.Statement)result; if (stmt != null) { b.Add(stmt); } } }
public override void LeaveEnumDefinition(AST.EnumDefinition node) { LeaveTypeDefinition(node); base.LeaveEnumDefinition(node); }
public override void LeaveInterfaceDefinition(AST.InterfaceDefinition node) { LeaveTypeDefinition(node); base.LeaveInterfaceDefinition(node); }
public static IReturnType CreateReturnType(AST.TypeReference reference, IClass callingClass, IMethodOrProperty callingMember, int caretLine, int caretColumn, IProjectContent projectContent) { System.Diagnostics.Debug.Assert(projectContent != null); if (reference == null) { return GetDefaultReturnType(projectContent); } if (reference is AST.ArrayTypeReference) { AST.ArrayTypeReference arr = (AST.ArrayTypeReference)reference; return new ArrayReturnType(projectContent, CreateReturnType(arr.ElementType, callingClass, callingMember, caretLine, caretColumn, projectContent), (arr.Rank != null) ? (int)arr.Rank.Value : 1); } else if (reference is AST.SimpleTypeReference) { string name = ((AST.SimpleTypeReference)reference).Name; IReturnType rt; int typeParameterCount = (reference is AST.GenericTypeReference) ? ((AST.GenericTypeReference)reference).GenericArguments.Count : 0; if (name == "duck") rt = new BooResolver.DuckClass(new DefaultCompilationUnit(projectContent)).DefaultReturnType; else if (BooAmbience.ReverseTypeConversionTable.ContainsKey(name)) rt = new GetClassReturnType(projectContent, BooAmbience.ReverseTypeConversionTable[name], typeParameterCount); else if (callingClass == null) rt = new GetClassReturnType(projectContent, name, typeParameterCount); else rt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, name, typeParameterCount); if (typeParameterCount > 0) { AST.TypeReferenceCollection arguments = ((AST.GenericTypeReference)reference).GenericArguments; // GenericTypeReference derives from SimpleTypeReference IReturnType[] typeArguments = new IReturnType[arguments.Count]; for (int i = 0; i < typeArguments.Length; i++) { typeArguments[i] = CreateReturnType(arguments[i], callingClass, callingMember, caretLine, caretColumn, projectContent); } rt = new ConstructedReturnType(rt, typeArguments); } return rt; } else if (reference is AST.CallableTypeReference) { AST.CallableTypeReference ctr = (AST.CallableTypeReference)reference; AnonymousMethodReturnType amrt = new AnonymousMethodReturnType(new DefaultCompilationUnit(projectContent)); if (ctr.ReturnType != null) { amrt.MethodReturnType = CreateReturnType(ctr.ReturnType, callingClass, callingMember, caretLine, caretColumn, projectContent); } amrt.MethodParameters = new List<IParameter>(); AddParameters(ctr.Parameters, amrt.MethodParameters, callingMember, callingClass ?? new DefaultClass(new DefaultCompilationUnit(projectContent), "__Dummy")); return amrt; } else { throw new NotSupportedException("unknown reference type: " + reference.ToString()); } }
public override void OnField(AST.Field node) { DefaultField field = new DefaultField(CreateReturnType(node), node.Name, GetModifier(node), GetRegion(node), OuterClass); ConvertAttributes(node, field); OuterClass.Fields.Add(field); }
public override void OnConstructor(AST.Constructor node) { if (node.IsSynthetic && node.Parameters.Count == 0) return; Constructor ctor = new Constructor(GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass); ConvertAttributes(node, ctor); ConvertParameters(node.Parameters, ctor); _currentClass.Peek().Methods.Add(ctor); ctor.UserData = node; }
protected override void OnError(AST.Node node, Exception error) { MessageService.ShowError(error, "error processing " + node.ToCodeString()); }
public override bool EnterInterfaceDefinition(AST.InterfaceDefinition node) { EnterTypeDefinition(node, ClassType.Interface); return base.EnterInterfaceDefinition(node); }
public override void OnCallableDefinition(AST.CallableDefinition node) { LoggingService.Debug("OnCallableDefinition: " + node.FullName); DomRegion region = GetRegion(node); DefaultClass c = new DefaultClass(_cu, ClassType.Delegate, GetModifier(node), region, OuterClass); ConvertAttributes(node, c); c.BaseTypes.Add(c.ProjectContent.SystemTypes.Delegate); c.FullyQualifiedName = node.FullName; if (_currentClass.Count > 0) { OuterClass.InnerClasses.Add(c); } else { _cu.Classes.Add(c); } _currentClass.Push(c); // necessary for CreateReturnType ConvertTemplates(node, c); IReturnType returnType = CreateReturnType(node.ReturnType); DefaultMethod invokeMethod = new DefaultMethod("Invoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); ConvertParameters(node.Parameters, invokeMethod); c.Methods.Add(invokeMethod); invokeMethod = new DefaultMethod("BeginInvoke", c.ProjectContent.SystemTypes.IAsyncResult, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); ConvertParameters(node.Parameters, invokeMethod); if (invokeMethod.Parameters == DefaultParameter.EmptyParameterList) { invokeMethod.Parameters = new List<IParameter>(); } invokeMethod.Parameters.Add(new DefaultParameter("callback", c.ProjectContent.SystemTypes.AsyncCallback, DomRegion.Empty)); invokeMethod.Parameters.Add(new DefaultParameter("object", c.ProjectContent.SystemTypes.Object, DomRegion.Empty)); c.Methods.Add(invokeMethod); invokeMethod = new DefaultMethod("EndInvoke", returnType, ModifierEnum.Public, DomRegion.Empty, DomRegion.Empty, c); invokeMethod.Parameters.Add(new DefaultParameter("result", c.ProjectContent.SystemTypes.IAsyncResult, DomRegion.Empty)); c.Methods.Add(invokeMethod); _currentClass.Pop(); }
IReturnType CreateReturnType(AST.Property property) { if (property.Type == null && property.Getter != null && property.Getter.Body != null) return new BooInferredReturnType(property.Getter.Body, OuterClass, false); return CreateReturnType(property.Type); }
IReturnType CreateReturnType(AST.Method node, IMethod method) { if (node.ReturnType == null) return new BooInferredReturnType(node.Body, OuterClass, false); return CreateReturnType(node.ReturnType, method); }
IReturnType CreateReturnType(AST.Field field) { if (field.Type == null) { if (field.Initializer != null) return new BooInferredReturnType(field.Initializer, OuterClass); else return GetDefaultReturnType(_cu.ProjectContent); } else { return CreateReturnType(field.Type); } }
IReturnType CreateReturnType(AST.TypeReference reference) { return CreateReturnType(reference, null); }
public override void LeaveModule(AST.Module node) { if (_currentClass.Count != 0) LeaveTypeDefinition(node); base.LeaveModule(node); }
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+")"); }
public override bool EnterEnumDefinition(AST.EnumDefinition node) { EnterTypeDefinition(node, ClassType.Enum); return base.EnterEnumDefinition(node); }
public override void OnMethod(AST.Method node) { //LoggingService.Debug("Method: " + node.FullName + " (" + node.Modifiers + ")"); DefaultMethod method = new DefaultMethod(node.Name, null, GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass); foreach (AST.Attribute a in node.Attributes) { if (a.Name == "Extension" || a.Name == "Boo.Lang.Extension" || a.Name == "ExtensionAttribute" || a.Name == "Boo.Lang.ExtensionAttribute") { method.IsExtensionMethod = true; } } ConvertAttributes(node, method); ConvertTemplates(node, method); // return type must be assigned AFTER ConvertTemplates method.ReturnType = CreateReturnType(node, method); ConvertParameters(node.Parameters, method); _currentClass.Peek().Methods.Add(method); method.UserData = node; }
// cannot override OnNamespaceDeclaration - it's visited too late (after the type definitions) void HandleNamespaceDeclaration(AST.NamespaceDeclaration node) { if (node == null) return; string[] namespaceName = node.Name.Split(new char[] { '.' }, StringSplitOptions.RemoveEmptyEntries); foreach (string namePart in namespaceName) { _cu.UsingScope = new DefaultUsingScope { NamespaceName = PrependCurrentNamespace(namePart), Parent = _cu.UsingScope }; } }
public override void OnEnumMember(AST.EnumMember node) { DefaultField field = new DefaultField(OuterClass.DefaultReturnType, node.Name, ModifierEnum.Const | ModifierEnum.Public, GetRegion(node), OuterClass); ConvertAttributes(node, field); OuterClass.Fields.Add(field); }
public override void OnEvent(AST.Event node) { DomRegion region = GetRegion(node); DefaultEvent e = new DefaultEvent(node.Name, CreateReturnType(node.Type), GetModifier(node), region, region, OuterClass); ConvertAttributes(node, e); OuterClass.Events.Add(e); }
public override bool EnterModule(AST.Module node) { HandleNamespaceDeclaration(node.Namespace); if (!_firstModule && node.Members.Count > 0) { EnterTypeDefinition(node, ClassType.Module); } _firstModule = false; return base.EnterModule(node); }
public IReturnType GetTypeOfExpression(AST.Expression expr, IClass callingClass) { AST.Node node = expr; AST.LexicalInfo lexInfo; do { if (node == null) return null; lexInfo = node.LexicalInfo; node = node.ParentNode; } while (lexInfo == null || lexInfo.FileName == null); if (!Initialize(ParserService.GetParseInformation(lexInfo.FileName), lexInfo.Line, lexInfo.Column)) return null; if (callingClass != null) this.callingClass = callingClass; ResolveVisitor visitor = new ResolveVisitor(this); visitor.Visit(expr); if (visitor.ResolveResult == null) return null; else return visitor.ResolveResult.ResolvedType; }
public override void OnProperty(AST.Property node) { DefaultProperty property = new DefaultProperty(node.Name, CreateReturnType(node), GetModifier(node), GetRegion(node), GetClientRegion(node), OuterClass); ConvertAttributes(node, property); ConvertParameters(node.Parameters, property); if (node.Getter != null && node.Getter.Body != null) { property.GetterRegion = GetClientRegion(node.Getter); } if (node.Setter != null && node.Setter.Body != null) { property.SetterRegion = GetClientRegion(node.Setter); } property.IsIndexer = (node.Name == "self"); OuterClass.Properties.Add(property); property.UserData = node; }
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)); } } }
public IReturnType ConvertType(AST.TypeReference typeRef) { return ConvertVisitor.CreateReturnType(typeRef, callingClass, callingMember, caretLine, caretColumn, pc); }
public override void LeaveClassDefinition(AST.ClassDefinition node) { LeaveTypeDefinition(node); base.LeaveClassDefinition(node); }