public override void OnYieldStatement(YieldStatement node) { noReturnStatement = false; IProjectContent pc = context != null ? context.ProjectContent : ParserService.CurrentProjectContent; IReturnType enumerable = new GetClassReturnType(pc, "System.Collections.Generic.IEnumerable", 1); // Prevent creating an infinite number of InferredReturnTypes in inferring cycles parentReturnType.expression = new NullLiteralExpression(); IReturnType returnType; if (node.Expression == null) { returnType = ConvertVisitor.GetDefaultReturnType(pc); } else { returnType = new BooResolver().GetTypeOfExpression(node.Expression, context); } if (returnType != null) { returnType.GetUnderlyingClass(); // force to infer type } if (parentReturnType.expression == null) { // inferrence cycle with parentReturnType returnType = new GetClassReturnType(pc, "?", 0); } parentReturnType.expression = null; result = new ConstructedReturnType(enumerable, new IReturnType[] { returnType }); }
static IReturnType Parse(IProjectContent pc, IEnumerator <string> tokenizer) { string typeName = tokenizer.Current; if (typeName == null) { throw new ReflectionTypeNameSyntaxError("Unexpected end of type name"); } tokenizer.MoveNext(); int typeParameterCount; typeName = ReflectionClass.SplitTypeParameterCountFromReflectionName(typeName, out typeParameterCount); IReturnType rt = new GetClassReturnType(pc, typeName, typeParameterCount); if (tokenizer.Current == "[") { // this is a constructed type List <IReturnType> typeArguments = new List <IReturnType>(); do { tokenizer.MoveNext(); if (tokenizer.Current != "[") { throw new ReflectionTypeNameSyntaxError("Expected '['"); } tokenizer.MoveNext(); typeArguments.Add(Parse(pc, tokenizer)); if (tokenizer.Current != "]") { throw new ReflectionTypeNameSyntaxError("Expected ']' after generic argument"); } tokenizer.MoveNext(); } while (tokenizer.Current == ","); if (tokenizer.Current != "]") { throw new ReflectionTypeNameSyntaxError("Expected ']' after generic argument list"); } tokenizer.MoveNext(); rt = new ConstructedReturnType(rt, typeArguments); } while (tokenizer.Current == ",") { tokenizer.MoveNext(); string token = tokenizer.Current; if (token != null && token != "," && token != "[" && token != "]") { tokenizer.MoveNext(); } } return(rt); }
public override void OnGeneratorExpression(GeneratorExpression node) { ClearResult(); node.Expression.Accept(this); if (resolveResult != null) { IReturnType enumerable = new GetClassReturnType(projectContent, "System.Collections.Generic.IEnumerable", 1); MakeResult(new ConstructedReturnType(enumerable, new IReturnType[] { resolveResult.ResolvedType })); } else { MakeResult(new GetClassReturnType(projectContent, "System.Collections.IEnumerable", 0)); } }
static IReturnType Parse(IProjectContent pc, IEnumerator<string> tokenizer) { string typeName = tokenizer.Current; if (typeName == null) throw new ReflectionTypeNameSyntaxError("Unexpected end of type name"); tokenizer.MoveNext(); int typeParameterCount; typeName = ReflectionClass.SplitTypeParameterCountFromReflectionName(typeName, out typeParameterCount); IReturnType rt = new GetClassReturnType(pc, typeName, typeParameterCount); if (tokenizer.Current == "[") { // this is a constructed type List<IReturnType> typeArguments = new List<IReturnType>(); do { tokenizer.MoveNext(); if (tokenizer.Current != "[") throw new ReflectionTypeNameSyntaxError("Expected '['"); tokenizer.MoveNext(); typeArguments.Add(Parse(pc, tokenizer)); if (tokenizer.Current != "]") throw new ReflectionTypeNameSyntaxError("Expected ']' after generic argument"); tokenizer.MoveNext(); } while (tokenizer.Current == ","); if (tokenizer.Current != "]") throw new ReflectionTypeNameSyntaxError("Expected ']' after generic argument list"); tokenizer.MoveNext(); rt = new ConstructedReturnType(rt, typeArguments); } while (tokenizer.Current == ",") { tokenizer.MoveNext(); string token = tokenizer.Current; if (token != null && token != "," && token != "[" && token != "]") tokenizer.MoveNext(); } return rt; }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, bool useLazyReturnType) { if (reference == null) { return(null); } if (reference.IsNull) { return(null); } if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } if (t == null && callingMember is IMethod && (callingMember as IMethod).TypeParameters != null) { foreach (ITypeParameter tp in (callingMember as IMethod).TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } } } if (t == null) { if (reference.Type != reference.SystemType) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.SystemType); if (c != null) { t = c.DefaultReturnType; } else { t = new GetClassReturnType(projectContent, reference.SystemType, 0); } } else { int typeParameterCount = reference.GenericTypes.Count; if (useLazyReturnType) { if (reference.IsGlobal) { t = new GetClassReturnType(projectContent, reference.SystemType, typeParameterCount); } else if (callingClass != null) { t = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.SystemType, typeParameterCount); } } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.SystemType, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.SystemType, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { if (reference.GenericTypes.Count == 0 && !reference.IsArrayType) { // reference to namespace is possible if (reference.IsGlobal) { if (projectContent.NamespaceExists(reference.Type)) { return(new NamespaceReturnType(reference.Type)); } } else { string name = projectContent.SearchNamespace(reference.Type, callingClass, (callingClass == null) ? null : callingClass.CompilationUnit, caretLine, caretColumn); if (name != null) { return(new NamespaceReturnType(name)); } } } return(null); } } } } if (reference.GenericTypes.Count > 0) { List <IReturnType> para = new List <IReturnType>(reference.GenericTypes.Count); for (int i = 0; i < reference.GenericTypes.Count; ++i) { para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, useLazyReturnType)); } t = new ConstructedReturnType(t, para); } return(WrapArray(projectContent, t, reference)); }
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 static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, ReturnTypeOptions options) { if (reference == null) return null; if (reference.IsNull) return null; if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } bool useLazyReturnType = (options & ReturnTypeOptions.Lazy) == ReturnTypeOptions.Lazy; bool isBaseTypeReference = (options & ReturnTypeOptions.BaseTypeReference) == ReturnTypeOptions.BaseTypeReference; LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } IMethod callingMethod = callingMember as IMethod; if (t == null && callingMethod != null) { foreach (ITypeParameter tp in callingMethod.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } } } if (t == null) { int typeParameterCount = reference.GenericTypes.Count; if (reference.IsKeyword) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.Type, typeParameterCount); if (c != null) t = c.DefaultReturnType; else t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } else { if (useLazyReturnType || isBaseTypeReference) { if (reference.IsGlobal) { t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } else if (callingClass != null) { SearchClassReturnType scrt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.Type, typeParameterCount); if (isBaseTypeReference) scrt.LookForInnerClassesInDeclaringClass = false; t = scrt; } } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.Type, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.Type, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { return null; } } } } if (reference.GenericTypes.Count > 0) { IReturnType[] para = new IReturnType[reference.GenericTypes.Count]; for (int i = 0; i < reference.GenericTypes.Count; ++i) { para[i] = CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, options); } t = new ConstructedReturnType(t, para); } for (int i = 0; i < reference.PointerNestingLevel; i++) { t = new PointerReturnType(t); } return WrapArray(projectContent, t, reference); }
protected override string GenerateCode(LanguageProperties language, IClass currentClass) { StringBuilder builder = new StringBuilder(); IDocumentLine line = editor.Document.GetLineForOffset(anchor.Offset); string indent = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset); bool implementInterface = this.implementInterface.IsChecked == true; bool hasOnPropertyChanged = HasOnPropertyChanged(currentClass); bool useEventArgs = false; if (implementInterface && !currentClass.IsStatic) { if (!hasOnPropertyChanged) { var nodes = new List <AbstractNode>(); var rt = new GetClassReturnType(currentClass.ProjectContent, "System.ComponentModel.INotifyPropertyChanged", 0); if (!currentClass.ClassInheritanceTree.Any(bt => bt.FullyQualifiedName == "System.ComponentModel.INotifyPropertyChanged")) { int insertion = editor.Document.PositionToOffset(currentClass.BodyRegion.BeginLine, currentClass.BodyRegion.BeginColumn); if (currentClass.BaseTypes.Count > 0) { editor.Document.Insert(insertion, ", INotifyPropertyChanged"); } else { editor.Document.Insert(insertion, " : INotifyPropertyChanged"); } } language.CodeGenerator.ImplementInterface(nodes, rt, false, currentClass); var ev = rt.GetEvents().First(e => e.Name == "PropertyChanged"); MethodDeclaration onEvent = language.CodeGenerator.CreateOnEventMethod(new DefaultEvent(ev.Name, ev.ReturnType, ev.Modifiers, ev.Region, ev.BodyRegion, currentClass)); nodes.Add(onEvent); onEvent.Parameters[0].TypeReference = new TypeReference("string", true); onEvent.Parameters[0].ParameterName = "propertyName"; ((RaiseEventStatement)onEvent.Body.Children[0]).Arguments[1] = new ObjectCreateExpression(new TypeReference("PropertyChangedEventArgs"), new List <Expression> { new IdentifierExpression("propertyName") }); foreach (var node in nodes) { builder.AppendLine(language.CodeGenerator.GenerateCode(node, indent)); } useEventArgs = false; } else { useEventArgs = currentClass.DefaultReturnType.GetMethods().First(m => m.Name == "OnPropertyChanged").Parameters[0].ReturnType.FullyQualifiedName != "System.String"; } } foreach (FieldWrapper field in listBox.SelectedItems) { var prop = language.CodeGenerator.CreateProperty(field.Field, true, field.AddSetter); if (!field.Field.IsStatic && !currentClass.IsStatic && field.AddSetter && implementInterface) { var invocation = new ExpressionStatement(CreateInvocation(field.PropertyName, useEventArgs)); var assignment = prop.SetRegion.Block.Children[0]; prop.SetRegion.Block.Children.Clear(); prop.SetRegion.Block.AddChild( new IfElseStatement( new BinaryOperatorExpression(new IdentifierExpression(field.MemberName), BinaryOperatorType.InEquality, new IdentifierExpression("value")), new BlockStatement { Children = { assignment, invocation } } ) ); } builder.AppendLine(language.CodeGenerator.GenerateCode(prop, indent)); } return(builder.ToString().Trim()); }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, ReturnTypeOptions options) { if (reference == null) { return(null); } if (reference.IsNull) { return(null); } if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } bool useLazyReturnType = (options & ReturnTypeOptions.Lazy) == ReturnTypeOptions.Lazy; bool isBaseTypeReference = (options & ReturnTypeOptions.BaseTypeReference) == ReturnTypeOptions.BaseTypeReference; LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } IMethod callingMethod = callingMember as IMethod; if (t == null && callingMethod != null) { foreach (ITypeParameter tp in callingMethod.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.Type)) { t = new GenericReturnType(tp); break; } } } } if (t == null && reference.Type == "dynamic") { t = new DynamicReturnType(projectContent); } if (t == null) { int typeParameterCount = reference.GenericTypes.Count; if (reference.IsKeyword) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.Type, typeParameterCount); if (c != null) { t = c.DefaultReturnType; } else { t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } } else { if (useLazyReturnType || isBaseTypeReference) { if (reference.IsGlobal) { t = new GetClassReturnType(projectContent, reference.Type, typeParameterCount); } else if (callingClass != null) { SearchClassReturnType scrt = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.Type, typeParameterCount); if (isBaseTypeReference) { scrt.LookForInnerClassesInDeclaringClass = false; } t = scrt; } } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.Type, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.Type, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { return(null); } } } } if (reference.GenericTypes.Count > 0) { IReturnType[] para = new IReturnType[reference.GenericTypes.Count]; for (int i = 0; i < reference.GenericTypes.Count; ++i) { para[i] = CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, options); } t = new ConstructedReturnType(t, para); } for (int i = 0; i < reference.PointerNestingLevel; i++) { t = new PointerReturnType(t); } return(WrapArray(projectContent, t, reference)); }
CodeExpression CreateMemberExpression(CodeExpression target, string parentName, string name, bool isStatic) { _fieldReferenceType = null; string combinedName = parentName + "." + name; if (pc.GetClass(combinedName, 0) != null) { return(new CodeTypeReferenceExpression(combinedName)); } else if (pc.NamespaceExists(combinedName)) { return(new CodeTypeReferenceExpression(combinedName)); } GetClassReturnType rt = new GetClassReturnType(pc, parentName, 0); foreach (IProperty prop in rt.GetProperties()) { if (prop.IsStatic == isStatic && prop.Name == name) { _fieldReferenceType = prop.ReturnType; return(new CodePropertyReferenceExpression(target, name)); } } foreach (IEvent ev in rt.GetEvents()) { if (ev.IsStatic == isStatic && ev.Name == name) { _fieldReferenceType = ev.ReturnType; return(new CodeEventReferenceExpression(target, name)); } } foreach (IMethod me in rt.GetMethods()) { if (me.IsStatic == isStatic && me.Name == name) { _fieldReferenceType = me.ReturnType; CodeMethodReferenceExpression cmre = new CodeMethodReferenceExpression(target, name); cmre.UserData["methodUserData"] = me; return(cmre); } } foreach (IField field in rt.GetFields()) { if (field.IsStatic == isStatic && field.Name == name) { _fieldReferenceType = field.ReturnType; return(new CodeFieldReferenceExpression(target, name)); } } // unknown member, guess: if (char.IsUpper(name, 0)) { return(new CodePropertyReferenceExpression(target, name)); } else { return(new CodeFieldReferenceExpression(target, name)); } }
public static IReturnType CreateReturnType(TypeReference reference, IClass callingClass, IMember callingMember, int caretLine, int caretColumn, IProjectContent projectContent, bool useLazyReturnType) { if (reference == null) return null; if (reference.IsNull) return null; if (reference is InnerClassTypeReference) { reference = ((InnerClassTypeReference)reference).CombineToNormalTypeReference(); } LanguageProperties languageProperties = projectContent.Language; IReturnType t = null; if (callingClass != null && !reference.IsGlobal) { foreach (ITypeParameter tp in callingClass.TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } if (t == null && callingMember is IMethod && (callingMember as IMethod).TypeParameters != null) { foreach (ITypeParameter tp in (callingMember as IMethod).TypeParameters) { if (languageProperties.NameComparer.Equals(tp.Name, reference.SystemType)) { t = new GenericReturnType(tp); break; } } } } if (t == null) { if (reference.Type != reference.SystemType) { // keyword-type like void, int, string etc. IClass c = projectContent.GetClass(reference.SystemType); if (c != null) t = c.DefaultReturnType; else t = new GetClassReturnType(projectContent, reference.SystemType, 0); } else { int typeParameterCount = reference.GenericTypes.Count; if (useLazyReturnType) { if (reference.IsGlobal) t = new GetClassReturnType(projectContent, reference.SystemType, typeParameterCount); else if (callingClass != null) t = new SearchClassReturnType(projectContent, callingClass, caretLine, caretColumn, reference.SystemType, typeParameterCount); } else { IClass c; if (reference.IsGlobal) { c = projectContent.GetClass(reference.SystemType, typeParameterCount); t = (c != null) ? c.DefaultReturnType : null; } else if (callingClass != null) { t = projectContent.SearchType(new SearchTypeRequest(reference.SystemType, typeParameterCount, callingClass, caretLine, caretColumn)).Result; } if (t == null) { if (reference.GenericTypes.Count == 0 && !reference.IsArrayType) { // reference to namespace is possible if (reference.IsGlobal) { if (projectContent.NamespaceExists(reference.Type)) return new NamespaceReturnType(reference.Type); } else { string name = projectContent.SearchNamespace(reference.Type, callingClass, (callingClass == null) ? null : callingClass.CompilationUnit, caretLine, caretColumn); if (name != null) return new NamespaceReturnType(name); } } return null; } } } } if (reference.GenericTypes.Count > 0) { List<IReturnType> para = new List<IReturnType>(reference.GenericTypes.Count); for (int i = 0; i < reference.GenericTypes.Count; ++i) { para.Add(CreateReturnType(reference.GenericTypes[i], callingClass, callingMember, caretLine, caretColumn, projectContent, useLazyReturnType)); } t = new ConstructedReturnType(t, para); } return WrapArray(projectContent, t, reference); }