public void InstantiatedMethodByParameterTest () { // build "T MyMethod<T> (T[] a)" DomMethod method = new DomMethod (); method.Name = "MyMethod"; method.ReturnType = new DomReturnType ("T"); method.AddTypeParameter (new TypeParameter ("T")); DomReturnType returnType = new DomReturnType ("T"); returnType.ArrayDimensions = 1; method.Add (new DomParameter (method, "a", returnType)); // give int[] as param type. List<IReturnType> genArgs = new List<IReturnType> (); List<IReturnType> args = new List<IReturnType> (); returnType = new DomReturnType (DomReturnType.Int32.FullName); returnType.ArrayDimensions = 1; args.Add (returnType); IMethod instMethod = DomMethod.CreateInstantiatedGenericMethod (method, genArgs, args); // check (note that return type should be int and not int[]) Assert.AreEqual (DomReturnType.Int32.FullName, instMethod.ReturnType.FullName); Assert.AreEqual (0, instMethod.ReturnType.ArrayDimensions); Assert.AreEqual (DomReturnType.Int32.FullName, instMethod.Parameters[0].ReturnType.FullName); }
public InstantiatedParameterType (ProjectDom dom, ITypeParameterMember typeParameterMember, ITypeParameter tp) { IType outerType = typeParameterMember as IType ?? typeParameterMember.DeclaringType; typeparam = tp; compilationUnit = outerType.CompilationUnit; ClassType = ClassType.Class; Modifiers = Modifiers.Public; Name = tp.Name; Namespace = outerType.DecoratedFullName; Location = outerType.Location; DeclaringType = outerType; if (tp.Constraints.Count > 0) ClassType = ClassType.Interface; foreach (IReturnType rt in tp.Constraints) { if (FindCyclicReference (new HashSet<ITypeParameter> () { tp }, outerType, ((DomReturnType)rt).DecoratedFullName)) continue; IType bt = dom.SearchType (typeParameterMember, rt); IReturnType resolvedType = rt; if (bt != null) { resolvedType = new DomReturnType (bt); if (bt.ClassType == ClassType.Interface || BaseType != null) { AddInterfaceImplementation (resolvedType); } else { ClassType = bt.ClassType; BaseType = resolvedType; } } else { AddInterfaceImplementation (resolvedType); } } if (BaseType == null) BaseType = DomReturnType.Object; }
public virtual IType GetType(IReturnType returnType) { if (returnType == null) { return(null); } if (returnType.ArrayDimensions > 0) { DomReturnType newType = new DomReturnType(returnType.FullName); // dimensions are correctly updated when cropped newType.ArrayDimensions = returnType.ArrayDimensions - 1; newType.PointerNestingLevel = returnType.PointerNestingLevel; return(GetArrayType(newType)); } IType type = returnType.Type ?? GetType(((DomReturnType)returnType).DecoratedFullName, returnType.GenericArguments, true, true); if (type != null) { if (type.Kind == TypeKind.GenericInstantiation || type.Kind == TypeKind.GenericParameter) { return(type); } if (!returnType.Parts.Any(part => part.GenericArguments.Count != 0)) { return(type); } List <IReturnType> aggregatedGenerics = new List <IReturnType> (); foreach (IReturnTypePart part in returnType.Parts) { aggregatedGenerics.AddRange(part.GenericArguments); } return(CreateInstantiatedGenericType(type, aggregatedGenerics)); } return(type); /* * IReturnTypePart part = returnType.Parts [0]; * string name = !string.IsNullOrEmpty (returnType.Namespace) ? returnType.Namespace + "." + part.Name : part.Name; * IType ptype = GetType (name, part.GenericArguments, true, true); * if (ptype == null) * return null; * for (int n=1; n < returnType.Parts.Count; n++) { * part = returnType.Parts [n]; * ptype = SearchInnerType (ptype, part.Name, part.GenericArguments.Count, true); * if (ptype != null) * break; * if (ptype == null) * return null; * if (part.GenericArguments.Count > 0) * ptype = CreateInstantiatedGenericType (ptype, part.GenericArguments); * } * return ptype; */ }
static NSObjectInfoService () { string wrapperRootNamespace = "MonoTouch"; string foundation = wrapperRootNamespace + ".Foundation"; connectAttType = new DomReturnType (foundation, "ConnectAttribute"); exportAttType = new DomReturnType (foundation, "ExportAttribute"); registerAttType = new DomReturnType (foundation, "RegisterAttribute"); modelAttType = new DomReturnType (foundation, "ModelAttribute"); nsobjectType = new DomReturnType (foundation, "NSObject"); }
public override IMember ImplementMember(RefactorerContext ctx, IType cls, IMember member, IReturnType privateImplementationType) { if (privateImplementationType != null) { // Workaround for bug in the code generator. Generic private implementation types are not generated correctly when they are generic. Ambience amb = new CSharpAmbience(); string tn = amb.GetString(privateImplementationType, OutputFlags.IncludeGenerics | OutputFlags.UseFullName | OutputFlags.UseIntrinsicTypeNames); privateImplementationType = new DomReturnType(tn); } return(base.ImplementMember(ctx, cls, member, privateImplementationType)); }
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) { if (collectionInitializerExpression.CreateExpressions.Count == 0) { return(null); } DomReturnType type = (DomReturnType)ResolveType(collectionInitializerExpression.CreateExpressions[0]); type.ArrayDimensions++; return(CreateResult(type)); }
static NSObjectInfoService() { string wrapperRootNamespace = "MonoTouch"; string foundation = wrapperRootNamespace + ".Foundation"; connectAttType = new DomReturnType(foundation, "ConnectAttribute"); exportAttType = new DomReturnType(foundation, "ExportAttribute"); registerAttType = new DomReturnType(foundation, "RegisterAttribute"); modelAttType = new DomReturnType(foundation, "ModelAttribute"); nsobjectType = new DomReturnType(foundation, "NSObject"); }
IEnumerable <KeyValuePair <IMember, IReturnType> > YieldImpls(KeyValuePair <IType, IEnumerable <TreeIter> > kvp) { bool is_interface = kvp.Key.ClassType == ClassType.Interface; IReturnType privateImplementationType = new DomReturnType(kvp.Key.FullName); foreach (TreeIter memberIter in kvp.Value) { yield return(new KeyValuePair <IMember, IReturnType> ( GetIMember(memberIter), (is_interface && GetExplicit(memberIter)) ? privateImplementationType : null)); } }
public NSObjectInfoService (string wrapperRoot) { this.WrapperRoot = wrapperRoot; string foundation = wrapperRoot + ".Foundation"; connectAttType = new DomReturnType (foundation, "ConnectAttribute"); exportAttType = new DomReturnType (foundation, "ExportAttribute"); iboutletAttType = new DomReturnType (foundation, "OutletAttribute"); ibactionAttType = new DomReturnType (foundation, "ActionAttribute"); registerAttType = new DomReturnType (foundation, "RegisterAttribute"); modelAttType = new DomReturnType (foundation, "ModelAttribute"); nsobjectType = new DomReturnType (foundation, "NSObject"); }
public NSObjectInfoService(string wrapperRoot) { this.WrapperRoot = wrapperRoot; string foundation = wrapperRoot + ".Foundation"; connectAttType = new DomReturnType(foundation, "ConnectAttribute"); exportAttType = new DomReturnType(foundation, "ExportAttribute"); iboutletAttType = new DomReturnType(foundation, "OutletAttribute"); ibactionAttType = new DomReturnType(foundation, "ActionAttribute"); registerAttType = new DomReturnType(foundation, "RegisterAttribute"); modelAttType = new DomReturnType(foundation, "ModelAttribute"); nsobjectType = new DomReturnType(foundation, "NSObject"); }
public static List <string> GetResolveableNamespaces(RefactoringOptions options, out bool resolveDirect) { IReturnType returnType = null; INRefactoryASTProvider astProvider = RefactoringService.GetASTProvider(DesktopService.GetMimeTypeForUri(options.Document.FileName)); if (options.ResolveResult != null && options.ResolveResult.ResolvedExpression != null) { if (astProvider != null) { returnType = astProvider.ParseTypeReference(options.ResolveResult.ResolvedExpression.Expression).ConvertToReturnType(); } if (returnType == null) { returnType = DomReturnType.GetSharedReturnType(options.ResolveResult.ResolvedExpression.Expression); } } List <string> namespaces; if (options.ResolveResult is UnresolvedMemberResolveResult) { namespaces = new List <string> (); UnresolvedMemberResolveResult unresolvedMemberResolveResult = options.ResolveResult as UnresolvedMemberResolveResult; IType type = unresolvedMemberResolveResult.TargetResolveResult != null?options.Dom.GetType(unresolvedMemberResolveResult.TargetResolveResult.ResolvedType) : null; if (type != null) { List <IType> allExtTypes = DomType.GetAccessibleExtensionTypes(options.Dom, null); List <IMethod> extensionMethods = type.GetExtensionMethods(allExtTypes); foreach (ExtensionMethod method in extensionMethods) { if (method.Name == unresolvedMemberResolveResult.MemberName) { string ns = method.OriginalMethod.DeclaringType.Namespace; if (!namespaces.Contains(ns) && !options.Document.CompilationUnit.Usings.Any(u => u.Namespaces.Contains(ns))) { namespaces.Add(ns); } } } } resolveDirect = false; } else { namespaces = new List <string> (options.Dom.ResolvePossibleNamespaces(returnType)); resolveDirect = true; } return(namespaces); }
public override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) { if (resolver.CallingType == null) { return(CreateResult(DomReturnType.Void)); } ThisResolveResult result = new ThisResolveResult(); result.CallingType = resolver.CallingType; result.CallingMember = resolver.CallingMember; result.UnresolvedType = result.ResolvedType = DomReturnType.GetSharedReturnType(new DomReturnType(resolver.CallingType)); return(result); }
TypeParameter ConvertTemplateDefinition (ICSharpCode.NRefactory.Ast.TemplateDefinition template) { TypeParameter parameter = new TypeParameter (template.Name); foreach (ICSharpCode.NRefactory.Ast.TypeReference typeRef in template.Bases) { if (typeRef.Type == "constraint: struct") parameter.ValueTypeRequired = true; else if (typeRef.Type == "constraint: class") parameter.ClassRequired = true; else if (typeRef.Type == "constraint: new") parameter.ConstructorRequired = true; else { DomReturnType rt = ConvertReturnType (typeRef); parameter.AddConstraint (rt); } } return parameter; }
public static IReturnType ReadReturnType(BinaryReader reader, INameDecoder nameTable) { if (ReadNull(reader)) { return(null); } byte index = reader.ReadByte(); if (index < 0xFF) { return(DomReturnType.GetSharedReturnType(index)); } string ns = ReadString(reader, nameTable); List <IReturnTypePart> parts = new List <IReturnTypePart> (); uint partCount = ReadUInt(reader, 500); while (partCount-- > 0) { ReturnTypePart part = new ReturnTypePart(); parts.Add(part); part.Name = ReadString(reader, nameTable); part.IsGenerated = reader.ReadBoolean(); uint arguments = ReadUInt(reader, 1000); while (arguments-- > 0) { part.AddTypeParameter(ReadReturnType(reader, nameTable)); } } DomReturnType result = new DomReturnType(ns, parts); result.PointerNestingLevel = reader.ReadInt32(); result.IsNullable = reader.ReadBoolean(); result.IsByRef = reader.ReadBoolean(); int arrayDimensions = reader.ReadInt32(); int[] dims = new int [arrayDimensions]; for (int n = 0; n < arrayDimensions; n++) { dims [n] = reader.ReadInt32(); } result.SetDimensions(dims); return(result); }
internal IReturnType GetSharedReturnType(IReturnType rt) { string id = rt.ToInvariantString(); IReturnType s; if (!returnTypeCache.TryGetValue(id, out s)) { s = DomReturnType.GetSharedReturnType(rt, true); if (s == null) { s = rt; returnTypeCache [id] = rt; } } return(s); }
public override INode Visit(IReturnType type, IType typeToInstantiate) { DomReturnType copyFrom = (DomReturnType)type; IReturnType res; //Console.WriteLine ("Transfer:" + copyFrom.DecoratedFullName); if (typeTable.TryGetValue(copyFrom.DecoratedFullName, out res)) { if (type.ArrayDimensions == 0 && type.GenericArguments.Count == 0) { return(res); } } return(base.Visit(type, typeToInstantiate)); }
internal IReturnType GetSharedReturnType(IReturnType rt) { string id = rt.ToInvariantString(); IReturnType s; if (returnTypeCache.TryGetValue(id, out s)) { return(s); } s = DomReturnType.GetSharedReturnType(rt); if (object.ReferenceEquals(s, rt)) { returnTypeCache [id] = rt; } return(s); }
public string GetSimpleTypeName(string fullTypeName) { if (CurrentContext.ParsedDocument == null) { return(fullTypeName); } DomReturnType returnType; int idx = fullTypeName.IndexOf('#'); if (idx < 0) { returnType = new DomReturnType(fullTypeName); } else { returnType = new DomReturnType(fullTypeName.Substring(0, idx), fullTypeName.Substring(idx + 1)); } return(CurrentContext.ParsedDocument.CompilationUnit.ShortenTypeName(returnType, CurrentContext.InsertPosition.Line, CurrentContext.InsertPosition.Column).FullName); }
// static ProjectDom GetMLDom (MoonlightProject project) // { // return ProjectDomService.GetAssemblyDom ( // MonoDevelop.Core.Runtime.SystemAssemblyService.GetAssemblyNameForVersion ( // "System.Windows", GetProjectTargetFramework (project))); // } public static IEnumerable <IType> ListControlClasses(ProjectDom database, string namespac) { if (database == null) { yield break; } DomReturnType swd = new DomReturnType("System.Windows.DependencyObject"); //return classes if they derive from system.web.ui.control foreach (IMember mem in database.GetNamespaceContents(namespac, true, true)) { IType cls = mem as IType; if (cls != null && !cls.IsAbstract && cls.IsPublic && cls.IsBaseType(swd)) { yield return(cls); } } }
public void GetGenericType() { List <IReturnType> args = new List <IReturnType> (); DomReturnType rt = new DomReturnType("System.String"); args.Add(rt); IType type = mainProject.GetType("CompletionDbTest.SomeGeneric", args); Assert.IsNotNull(type); Assert.AreEqual("CompletionDbTest.SomeGeneric[System.String]", type.FullName); Assert.AreEqual(0, type.TypeParameters.Count); IMethod met = FindMember(type, "Run") as IMethod; Assert.IsNotNull(met); Assert.AreEqual(1, met.Parameters.Count); Assert.AreEqual("System.String", met.Parameters[0].ReturnType.FullName); Assert.IsNotNull(met.ReturnType); Assert.AreEqual("System.String", met.ReturnType.FullName); type = mainProject.GetType("Library2.GenericWidget"); Assert.IsNotNull(type); Assert.AreEqual("Library2.GenericWidget", type.FullName); Assert.AreEqual(0, type.TypeParameters.Count); type = mainProject.GetType("Library2.GenericWidget", 1, true); Assert.IsNotNull(type); Assert.AreEqual("Library2.GenericWidget", type.FullName); Assert.AreEqual(1, type.TypeParameters.Count); type = mainProject.GetType("Library2.GenericWidget", 2, true); Assert.IsNotNull(type); Assert.AreEqual("Library2.GenericWidget", type.FullName); Assert.AreEqual(2, type.TypeParameters.Count); type = mainProject.GetType("Library2.GenericWidget", 3, true); Assert.IsNull(type); // Inner generic type type = mainProject.GetType("Library2.Container.InnerClass1", 1, true); Assert.IsNotNull(type); }
public IReturnType GetTypeSafe (Expression expression) { ResolveResult result = Resolve (expression); if (expression is LambdaExpression) { var lambda = (LambdaExpression)expression; var bodyType = GetTypeSafe (lambda.ExpressionBody); DomReturnType constructedLambdaType = new DomReturnType (bodyType.FullName == DomReturnType.Void.FullName ? "System.Action" : "System.Func"); foreach (var param in lambda.Parameters) { var typeParam = GetTypeSafe (param); // add void place holder for types that can't be resolved. if (typeParam == null || string.IsNullOrEmpty (typeParam.FullName)) typeParam = DomReturnType.Void; constructedLambdaType.AddTypeParameter (typeParam); } if (bodyType.FullName != DomReturnType.Void.FullName) constructedLambdaType.AddTypeParameter (bodyType ?? result.ResolvedType); return constructedLambdaType; } return result.ResolvedType ?? DomReturnType.Void; }
public IReturnType GetResolvedType(RefactoringOptions options, ResolveResult resolveResult) { var result = resolveResult.ResolvedType; if (result == null || string.IsNullOrEmpty(result.Name)) { result = DomReturnType.Object; } if (resolveResult is MethodResolveResult) { var mrr = (MethodResolveResult)resolveResult; if (!mrr.GetsInvoked) { var method = options.SelectedItem as IMethod ?? mrr.MostLikelyMethod; DomReturnType type; if (method.ReturnType == null || method.ReturnType.FullName == DomReturnType.Void.FullName) { type = new DomReturnType("System.Action"); } else { type = new DomReturnType("System.Func"); } foreach (var param in method.Parameters) { type.AddTypeParameter(param.ReturnType); } if (method.ReturnType != null && method.ReturnType.FullName != DomReturnType.Void.FullName) { type.AddTypeParameter(method.ReturnType); } result = type; } } return(result); }
public NSObjectInfoTracker (DotNetProject project, string wrapperRootNamespace) { this.project = project; string foundation = wrapperRootNamespace + ".Foundation"; connectAttType = new DomReturnType (foundation, "ConnectAttribute"); exportAttType = new DomReturnType (foundation, "ExportAttribute"); registerAttType = new DomReturnType (foundation, "RegisterAttribute"); modelAttType = new DomReturnType (foundation, "ModelAttribute"); nsobjectType = new DomReturnType (foundation, "NSObject"); //FIXME: might there be a race here? var dom = ProjectDomService.GetProjectDom (project); if (dom == null) { subscribedDomLoaded = true; ProjectDomService.DomRegistered += DomLoaded; } else { System.Threading.ThreadPool.QueueUserWorkItem (delegate { DomLoaded (dom); }); } }
static IReturnType ConvertTypeReference(TypeReference typeRef) { if (typeRef == null) { return(null); } DomReturnType result = new DomReturnType(typeRef.Type); foreach (TypeReference genericArgument in typeRef.GenericTypes) { result.AddTypeParameter(ConvertTypeReference(genericArgument)); } result.PointerNestingLevel = typeRef.PointerNestingLevel; if (typeRef.IsArrayType) { result.ArrayDimensions = typeRef.RankSpecifier.Length; for (int i = 0; i < typeRef.RankSpecifier.Length; i++) { result.SetDimension(i, typeRef.RankSpecifier[i]); } } return(result); }
public void ExtensionMethodTest() { // build "T MyMethod<T, S> (this KeyValuePair<T, S> a, S b)" DomMethod method = new DomMethod(); method.Name = "MyMethod"; method.ReturnType = new DomReturnType("T"); method.AddTypeParameter(new TypeParameter("T")); method.AddTypeParameter(new TypeParameter("S")); DomReturnType returnType = new DomReturnType("KeyValuePair"); returnType.AddTypeParameter(new DomReturnType("T")); returnType.AddTypeParameter(new DomReturnType("S")); method.Add(new DomParameter(method, "a", returnType)); method.Add(new DomParameter(method, "b", new DomReturnType("S"))); // Build extendet type KeyValuePair<int, object> DomType type = new DomType("KeyValuePair"); type.AddTypeParameter(new TypeParameter("T")); type.AddTypeParameter(new TypeParameter("S")); IType extType = DomType.CreateInstantiatedGenericTypeInternal(type, new IReturnType[] { DomReturnType.Int32, DomReturnType.Object }); Console.WriteLine(extType); // extend method List <IReturnType> genArgs = new List <IReturnType> (); List <IReturnType> args = new List <IReturnType> (); ExtensionMethod extMethod = new ExtensionMethod(extType, method, genArgs, args); Console.WriteLine(extMethod); // check Assert.AreEqual(DomReturnType.Int32.FullName, extMethod.ReturnType.FullName); Assert.AreEqual(DomReturnType.Object.FullName, extMethod.Parameters[0].ReturnType.FullName); }
public override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) { if (collectionInitializerExpression.CreateExpressions.Count == 0) { return(null); } DomReturnType type = null; IType typeObject = null; for (int i = 0; i < collectionInitializerExpression.CreateExpressions.Count; i++) { DomReturnType curType = (DomReturnType)ResolveType(collectionInitializerExpression.CreateExpressions[i]); // if we found object or we have only one create expression we can stop if (curType.DecoratedFullName == DomReturnType.Object.DecoratedFullName || collectionInitializerExpression.CreateExpressions.Count == 1) { type = curType; break; } IType curTypeObject = resolver.Dom.GetType(curType); if (curTypeObject == null) { continue; } if (type == null || resolver.Dom.GetInheritanceTree(typeObject).Any(t => t.DecoratedFullName == curTypeObject.DecoratedFullName)) { type = curType; typeObject = curTypeObject; } } if (type != null) { type.ArrayDimensions++; } return(CreateResult(type)); }
public static DomReturnType ConvertToReturnType (this TypeReference typeRef) { if (typeRef == null) return null; DomReturnType result; if (typeRef is InnerClassTypeReference) { InnerClassTypeReference innerTypeRef = (InnerClassTypeReference)typeRef; result = innerTypeRef.BaseType.ConvertToReturnType (); result.Parts.Add (new ReturnTypePart (typeRef.Type)); } else { result = new DomReturnType (typeRef.Type); } foreach (TypeReference genericArgument in typeRef.GenericTypes) { result.AddTypeParameter (ConvertToReturnType (genericArgument)); } result.PointerNestingLevel = typeRef.PointerNestingLevel; if (typeRef.IsArrayType) { result.ArrayDimensions = typeRef.RankSpecifier.Length; for (int i = 0; i < typeRef.RankSpecifier.Length; i++) { result.SetDimension (i, typeRef.RankSpecifier[i]); } } return result; }
public static void Write(BinaryWriter writer, INameEncoder nameTable, IReturnType returnType) { if (WriteNull(writer, returnType)) { return; } int index = DomReturnType.GetIndex(returnType); if (index >= 0) { writer.Write((byte)index); return; } writer.Write((byte)0xFF); WriteString(returnType.Namespace, writer, nameTable); writer.Write((uint)returnType.Parts.Count); foreach (ReturnTypePart part in returnType.Parts) { WriteString(part.Name, writer, nameTable); writer.Write(part.IsGenerated); writer.Write((uint)part.GenericArguments.Count); foreach (IReturnType rtp in part.GenericArguments) { Write(writer, nameTable, rtp); } } writer.Write(returnType.PointerNestingLevel); writer.Write(returnType.IsNullable); writer.Write(returnType.IsByRef); writer.Write(returnType.ArrayDimensions); for (int n = 0; n < returnType.ArrayDimensions; n++) { writer.Write(returnType.GetDimension(n)); } }
public static IReturnType ReadReturnType (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable) { if (ReadNull (reader)) return null; byte index = reader.ReadByte (); if (index < 0xFF) return DomReturnType.GetSharedReturnType (index); string ns = ReadString (reader, nameTable); List<ReturnTypePart> parts = new List<ReturnTypePart> (); uint partCount = ReadUInt (reader, 500); while (partCount-- > 0) { ReturnTypePart part = new ReturnTypePart (); parts.Add (part); part.Name = ReadString (reader, nameTable); part.IsGenerated = reader.ReadBoolean (); uint arguments = ReadUInt (reader, 1000); while (arguments-- > 0) part.AddTypeParameter (ReadReturnType (reader, nameTable, objectTable)); } DomReturnType result = new DomReturnType (ns, parts); result.PointerNestingLevel = reader.ReadInt32 (); result.IsNullable = reader.ReadBoolean (); result.IsByRef = reader.ReadBoolean (); int arrayDimensions = reader.ReadInt32 (); int[] dims = new int [arrayDimensions]; for (int n=0; n<arrayDimensions; n++) dims [n] = reader.ReadInt32 (); result.SetDimensions (dims); return objectTable != null ? (IReturnType) objectTable.GetSharedObject (result) : result; }
public virtual IType GetType (IReturnType returnType) { if (returnType == null) return null; if (returnType.ArrayDimensions > 0) { DomReturnType newType = new DomReturnType (returnType.FullName); // dimensions are correctly updated when cropped newType.ArrayDimensions = returnType.ArrayDimensions - 1; newType.PointerNestingLevel = returnType.PointerNestingLevel; return GetArrayType (newType); } IType type = returnType.Type ?? GetType (((DomReturnType)returnType).DecoratedFullName, returnType.GenericArguments, true, true); if (type != null) { if (type.Kind == TypeKind.GenericInstantiation || type.Kind == TypeKind.GenericParameter) return type; if (!returnType.Parts.Any (part => part.GenericArguments.Count != 0)) return type; List<IReturnType> aggregatedGenerics = new List<IReturnType> (); foreach (IReturnTypePart part in returnType.Parts) { aggregatedGenerics.AddRange (part.GenericArguments); } return CreateInstantiatedGenericType (type, aggregatedGenerics); } return type; /* IReturnTypePart part = returnType.Parts [0]; string name = !string.IsNullOrEmpty (returnType.Namespace) ? returnType.Namespace + "." + part.Name : part.Name; IType ptype = GetType (name, part.GenericArguments, true, true); if (ptype == null) return null; for (int n=1; n < returnType.Parts.Count; n++) { part = returnType.Parts [n]; ptype = SearchInnerType (ptype, part.Name, part.GenericArguments.Count, true); if (ptype != null) break; if (ptype == null) return null; if (part.GenericArguments.Count > 0) ptype = CreateInstantiatedGenericType (ptype, part.GenericArguments); } return ptype; */ }
IReturnType ConvertReturnType (Mono.CSharp.Expression typeName) { if (typeName is TypeExpression) { var typeExpr = (Mono.CSharp.TypeExpression)typeName; return new DomReturnType (keywordTable [(int)typeExpr.Type.BuiltinType]); } if (typeName is Mono.CSharp.QualifiedAliasMember) { var qam = (Mono.CSharp.QualifiedAliasMember)typeName; // TODO: Overwork the return type model - atm we don't have a good representation // for qualified alias members. return new DomReturnType (qam.Name); } if (typeName is MemberAccess) { MemberAccess ma = (MemberAccess)typeName; var baseType = (DomReturnType)ConvertReturnType (ma.LeftExpression); baseType.Parts.Add (new ReturnTypePart (ma.Name)); AddTypeArguments (ma, baseType); return baseType; } if (typeName is SimpleName) { var sn = (SimpleName)typeName; var result = new DomReturnType (sn.Name); AddTypeArguments (sn, result); return result; } if (typeName is ComposedCast) { var cc = (ComposedCast)typeName; var baseType = (DomReturnType)ConvertReturnType (cc.Left); if (cc.Spec.IsNullable) { return new DomReturnType ("System.Nullable", true, new IReturnType[] { baseType }); } else if (cc.Spec.IsPointer) { baseType.PointerNestingLevel++; } else { baseType.ArrayDimensions++; baseType.SetDimension (baseType.ArrayDimensions - 1, cc.Spec.Dimension - 1); } return baseType; } MonoDevelop.Core.LoggingService.LogError ("Error while converting :" + typeName + " - unknown type name"); return new DomReturnType (DomReturnType.Void.FullName); }
public override IMember ImplementMember (RefactorerContext ctx, IType cls, IMember member, IReturnType privateImplementationType) { if (privateImplementationType != null) { // Workaround for bug in the code generator. Generic private implementation types are not generated correctly when they are generic. Ambience amb = new CSharpAmbience (); string tn = amb.GetString (privateImplementationType, OutputFlags.IncludeGenerics | OutputFlags.UseFullName | OutputFlags.UseIntrinsicTypeNames); privateImplementationType = new DomReturnType (tn); } return base.ImplementMember (ctx, cls, member, privateImplementationType); }
public override void Analyze(Mono.TextEditor.Document doc, LineSegment line, Chunk startChunk, int startOffset, int endOffset) { if (!MonoDevelop.Core.PropertyService.Get("EnableSemanticHighlighting", false) || doc == null || line == null || startChunk == null) { return; } int lineNumber = doc.OffsetToLineNumber(line.Offset); var ideDocument = IdeApp.Workbench.Documents.FirstOrDefault(d => d.FileName == doc.FileName); if (ideDocument == null) { return; } ParsedDocument parsedDocument = ideDocument.ParsedDocument; ICompilationUnit unit = parsedDocument != null ? parsedDocument.CompilationUnit : null; if (unit == null) { return; } var ctx = ProjectDomService.GetProjectDom(ideDocument.Project); for (Chunk chunk = startChunk; chunk != null; chunk = chunk.Next) { if (chunk.Style != "text") { continue; } char charBefore = chunk.Offset > 0 ? doc.GetCharAt(chunk.Offset - 1) : '}'; char ch; for (int i = chunk.Offset; i < chunk.EndOffset; i++) { ch = doc.GetCharAt(i); if (!Char.IsLetter(ch) || Char.IsLetterOrDigit(charBefore)) { charBefore = ch; continue; } int start = i; bool wasWhitespace = Char.IsWhiteSpace(charBefore); bool wasDot = false; int bracketCount = 0; while (start > 0) { ch = doc.GetCharAt(start); if (ch == '\n' || ch == '\r') { break; } bool isNamePart = IsNamePart(ch); if (wasWhitespace && isNamePart) { break; } if (ch == '<') { bracketCount--; if (bracketCount < 0) { start++; break; } start--; wasWhitespace = false; continue; } if (ch == '>') { if (wasWhitespace && !wasDot) { break; } bracketCount++; start--; wasWhitespace = false; continue; } bool isWhiteSpace = Char.IsWhiteSpace(ch); if (!isNamePart && !isWhiteSpace && ch != '.') { start++; break; } wasWhitespace = isWhiteSpace; wasDot = ch == '.' || wasDot && wasWhitespace; start--; } int end = i; int genericCount = 0; wasWhitespace = false; List <Segment> nameSegments = new List <Segment> (); while (end < chunk.EndOffset) { ch = doc.GetCharAt(end); if (wasWhitespace && IsNamePart(ch)) { break; } if (ch == '<') { genericCount = 1; while (end < doc.Length) { ch = doc.GetCharAt(end); if (ch == ',') { genericCount++; } if (ch == '>') { nameSegments.Add(new Segment(end, 1)); break; } end++; } break; } bool isWhiteSpace = Char.IsWhiteSpace(ch); if (!IsNamePart(ch) && !isWhiteSpace) { break; } wasWhitespace = isWhiteSpace; end++; } if (start >= end) { charBefore = ch; continue; } string typeString = doc.GetTextBetween(start, end); IReturnType returnType = NRefactoryResolver.ParseReturnType(new ExpressionResult(typeString)); int nameEndOffset = start; for (; nameEndOffset < end; nameEndOffset++) { ch = doc.GetCharAt(nameEndOffset); if (nameEndOffset >= i && ch == '<') { nameEndOffset++; break; } } nameSegments.Add(new Segment(i, nameEndOffset - i)); int column = i - line.Offset; IType callingType = unit.GetTypeAt(lineNumber, column); List <IReturnType> genericParams = null; if (genericCount > 0) { genericParams = new List <IReturnType> (); for (int n = 0; n < genericCount; n++) { genericParams.Add(new DomReturnType("A")); } } IType type = null; if (ctx != null) { type = ctx.SearchType(unit, callingType, new DomLocation(lineNumber, 1), returnType); } if (type == null && unit != null && returnType != null) { type = unit.GetType(returnType.FullName, returnType.GenericArguments.Count); } if (ctx != null && type == null && returnType != null) { DomReturnType rt = new DomReturnType(returnType); rt.Name += "Attribute"; type = ctx.SearchType(unit, callingType, new DomLocation(lineNumber, 1), rt); } if (type != null) { nameSegments.ForEach(segment => HighlightSegment(startChunk, segment, "keyword.semantic.type")); } charBefore = ch; } } }
internal static void AddType (ProjectDom dom, List<object> result, IReturnType returnType, IMember callingMember, bool showStatic) { if (returnType == null || returnType.FullName == "System.Void") return; if (returnType.ArrayDimensions > 0) { DomReturnType elementType = new DomReturnType (returnType.FullName); elementType.ArrayDimensions = returnType.ArrayDimensions - 1; for (int i = 0; i < elementType.ArrayDimensions; i++) { elementType.SetDimension (i, returnType.ArrayDimensions - 1); } elementType.PointerNestingLevel = returnType.PointerNestingLevel; AddType (dom, result, dom.GetArrayType (elementType), callingMember, showStatic); return; } IType type = dom.GetType (returnType); AddType (dom, result, type, callingMember, showStatic); }
protected override IEnumerable<string> GenerateCode (INRefactoryASTProvider astProvider, string indent, List<IBaseMember> includedMembers) { // Genereate Equals MethodDeclaration methodDeclaration = new MethodDeclaration (); methodDeclaration.Name = "Equals"; methodDeclaration.ReturnType = DomReturnType.Bool.ConvertToTypeReference (); methodDeclaration.Modifiers = ICSharpCode.NRefactory.CSharp.Modifiers.Public | ICSharpCode.NRefactory.CSharp.Modifiers.Override; methodDeclaration.Body = new BlockStatement (); methodDeclaration.Parameters.Add (new ParameterDeclaration (DomReturnType.Object.ConvertToTypeReference (), "obj")); IdentifierExpression paramId = new IdentifierExpression ("obj"); IfElseStatement ifStatement = new IfElseStatement (); ifStatement.Condition = new BinaryOperatorExpression (paramId, BinaryOperatorType.Equality, new PrimitiveExpression (null)); ifStatement.TrueStatement = new ReturnStatement (new PrimitiveExpression (false)); methodDeclaration.Body.Statements.Add (ifStatement); ifStatement = new IfElseStatement (); List<Expression> arguments = new List<Expression> (); arguments.Add (new ThisReferenceExpression ()); arguments.Add (paramId.Clone ()); ifStatement.Condition = new InvocationExpression (new IdentifierExpression ("ReferenceEquals"), arguments); ifStatement.TrueStatement = new ReturnStatement (new PrimitiveExpression (true)); methodDeclaration.Body.Statements.Add (ifStatement); ifStatement = new IfElseStatement (); ifStatement.Condition = new BinaryOperatorExpression (new InvocationExpression (new MemberReferenceExpression (paramId.Clone (), "GetType")), BinaryOperatorType.InEquality, new TypeOfExpression (new SimpleType (Options.EnclosingType.Name))); ifStatement.TrueStatement = new ReturnStatement (new PrimitiveExpression (false)); methodDeclaration.Body.Statements.Add (ifStatement); AstType varType = new DomReturnType (Options.EnclosingType).ConvertToTypeReference (); var varDecl = new VariableDeclarationStatement (varType, "other", new CastExpression (varType.Clone (), paramId.Clone ())); methodDeclaration.Body.Statements.Add (varDecl); IdentifierExpression otherId = new IdentifierExpression ("other"); Expression binOp = null; foreach (IMember member in includedMembers) { Expression right = new BinaryOperatorExpression (new IdentifierExpression (member.Name), BinaryOperatorType.Equality, new MemberReferenceExpression (otherId, member.Name)); if (binOp == null) { binOp = right; } else { binOp = new BinaryOperatorExpression (binOp, BinaryOperatorType.ConditionalAnd, right); } } methodDeclaration.Body.Statements.Add (new ReturnStatement (binOp)); yield return astProvider.OutputNode (this.Options.Dom, methodDeclaration, indent); methodDeclaration = new MethodDeclaration (); methodDeclaration.Name = "GetHashCode"; methodDeclaration.ReturnType = DomReturnType.Int32.ConvertToTypeReference (); methodDeclaration.Modifiers = ICSharpCode.NRefactory.CSharp.Modifiers.Public | ICSharpCode.NRefactory.CSharp.Modifiers.Override; methodDeclaration.Body = new BlockStatement (); binOp = null; foreach (IMember member in includedMembers) { Expression right; right = new InvocationExpression (new MemberReferenceExpression (new IdentifierExpression (member.Name), "GetHashCode")); IType type = Options.Dom.SearchType (Options.Document.ParsedDocument.CompilationUnit, member is IType ? ((IType)member) : member.DeclaringType, member.Location, member.ReturnType); if (type != null && type.ClassType != MonoDevelop.Projects.Dom.ClassType.Struct&& type.ClassType != MonoDevelop.Projects.Dom.ClassType.Enum) right = new ParenthesizedExpression (new ConditionalExpression (new BinaryOperatorExpression (new IdentifierExpression (member.Name), BinaryOperatorType.InEquality, new PrimitiveExpression (null)), right, new PrimitiveExpression (0))); if (binOp == null) { binOp = right; } else { binOp = new BinaryOperatorExpression (binOp, BinaryOperatorType.ExclusiveOr, right); } } BlockStatement uncheckedBlock = new BlockStatement (); uncheckedBlock.Statements.Add (new ReturnStatement (binOp)); methodDeclaration.Body.Statements.Add (new UncheckedStatement (uncheckedBlock)); yield return astProvider.OutputNode (this.Options.Dom, methodDeclaration, indent); }
/* // Check if 'type' has some decorations applied to it if (type is Mono.Cecil.TypeSpecification) { // Go through all levels of 'indirection', 'array dimensions' // and 'generic types' - in the end, we should get the actual // type of the ReturnType (but all data about its array // dimensions, levels of indirection and even its generic // parameters is correctly stored within ArrayCount and // ArrayDimensions, PointerNestingLevel and GenericArguments // respectively). if (type is ArrayType) { // This return type is obviously an array - add the rank ArrayType at = (ArrayType) type; if (arrays == null) arrays = new Stack<int>(); arrays.Push(at.Rank); type = at.ElementType; } else else if (type is Mono.Cecil.ReferenceType) { Mono.Cecil.ReferenceType rt = (Mono.Cecil.ReferenceType) type; byRef = true; type = rt.ElementType; } else if (type is PointerType) { // The type is a pointer PointerType pt = (PointerType) type; ++pointerNestingLevel; type = pt.ElementType; // Go down one level } else { // TODO: Check if we loose some relevant info here type = ((TypeSpecification)type).ElementType; }*/ public static DomReturnType GetReturnType (TypeReference typeReference) { if (typeReference == null) return new DomReturnType (DomReturnType.Void.ToInvariantString ()); if (typeReference is Mono.Cecil.GenericInstanceType) { Mono.Cecil.GenericInstanceType genType = (Mono.Cecil.GenericInstanceType)typeReference; DomReturnType result = GetReturnType (genType.ElementType); foreach (TypeReference typeRef in genType.GenericArguments) { DomReturnType param = GetReturnType (typeRef); foreach (ReturnTypePart part in result.Parts) { if (part.Tag is TypeDefinition) { TypeDefinition typeDef = (TypeDefinition)part.Tag; foreach (TypeReference typeParam in typeDef.GenericParameters) { if (typeParam.Name == param.Name) { part.AddTypeParameter (param); goto skip; } } } } result.AddTypeParameter (param); skip:; } return result; } if (typeReference is Mono.Cecil.ArrayType) { Mono.Cecil.ArrayType arrType = (Mono.Cecil.ArrayType)typeReference; DomReturnType result = GetReturnType (arrType.ElementType); result.ArrayDimensions++; result.SetDimension (result.ArrayDimensions - 1, arrType.Rank - 1); return result; } if (typeReference is Mono.Cecil.PointerType) { Mono.Cecil.PointerType ptrType = (Mono.Cecil.PointerType)typeReference; DomReturnType result = GetReturnType (ptrType.ElementType); if (result.ArrayDimensions > 0) result.ArrayPointerNestingLevel++; else result.PointerNestingLevel++; return result; } if (typeReference is Mono.Cecil.ByReferenceType) return GetReturnType (((Mono.Cecil.ByReferenceType)typeReference).ElementType); if (typeReference is Mono.Cecil.TypeDefinition) { Mono.Cecil.TypeDefinition typeDefinition = (Mono.Cecil.TypeDefinition)typeReference; DomReturnType result; if (typeDefinition.DeclaringType != null) { result = GetReturnType (typeDefinition.DeclaringType); result.Parts.Add (new ReturnTypePart (typeDefinition.Name)); result.Tag = typeDefinition; } else { result = new DomReturnType (typeDefinition.Name); result.Namespace = typeDefinition.Namespace; result.Tag = typeDefinition; } return result; } return new DomReturnType (DomCecilType.RemoveGenericParamSuffix (typeReference.FullName)); }
public string Visit(IMethod method, OutputSettings settings) { StringBuilder result = new StringBuilder(); result.Append(settings.EmitModifiers(base.GetString(method.Modifiers))); if (settings.IncludeReturnType && !settings.ReturnTypesLast && !method.IsConstructor && !method.IsFinalizer) { result.Append(GetString(method.ReturnType, settings)); result.Append(settings.Markup(" ")); } if (!settings.IncludeReturnType && settings.UseFullName) { result.Append(GetString(method.DeclaringType, OutputFlags.UseFullName)); result.Append(settings.Markup(".")); } AppendExplicitInterfaces(result, method, settings); if (method.IsConstructor) { result.Append(settings.EmitName(method, Format(FilterName(method.DeclaringType.Name)))); } else if (method.IsFinalizer) { result.Append(settings.EmitName(method, settings.Markup("~") + Format(FilterName(method.DeclaringType.Name)))); } else { result.Append(settings.EmitName(method, Format(FilterName(method.Name)))); } //this is only ever used if GeneralizeGenerics is true DomMethod.GenericMethodInstanceResolver resolver = null; if (settings.GeneralizeGenerics) { resolver = new DomMethod.GenericMethodInstanceResolver(); } if (settings.IncludeGenerics) { if (method.TypeParameters.Count > 0) { result.Append(settings.Markup("<")); InstantiatedMethod instantiatedMethod = method as InstantiatedMethod; for (int i = 0; i < method.TypeParameters.Count; i++) { if (i > 0) { result.Append(settings.Markup(settings.HideGenericParameterNames ? "," : ", ")); } if (!settings.HideGenericParameterNames) { if (instantiatedMethod != null) { result.Append(this.GetString(instantiatedMethod.GenericParameters[i], settings)); } else { if (settings.GeneralizeGenerics) { string generalizedName = "$M" + i; result.Append(generalizedName); var t = new DomReturnType(); t.Name = generalizedName; resolver.Add(method.DeclaringType.SourceProjectDom, new DomReturnType(method.TypeParameters[i].Name), t); } else { result.Append(NetToCSharpTypeName(method.TypeParameters[i].Name)); } } } } result.Append(settings.Markup(">")); } } if (settings.IncludeParameters) { CSharpFormattingPolicy policy = GetPolicy(settings); if (policy.BeforeMethodCallParentheses) { result.Append(settings.Markup(" ")); } result.Append(settings.Markup("(")); bool first = !settings.StaticUsage; if (method.Parameters != null) { foreach (IParameter parameter in method.Parameters) { if (settings.HideExtensionsParameter && method.IsExtension && first) { continue; } if (method.IsExtension && first) { result.Append(settings.Markup("this ")); } if (!first) { result.Append(settings.Markup(", ")); } if (settings.GeneralizeGenerics) { AppendParameter(settings, result, (IParameter)resolver.Visit(parameter, method)); } else { AppendParameter(settings, result, parameter); } first = false; } } result.Append(settings.Markup(")")); } OutputConstraints(result, settings, method.TypeParameters); if (settings.IncludeReturnType && settings.ReturnTypesLast && !method.IsConstructor && !method.IsFinalizer) { result.Append(settings.Markup(" : ")); result.Append(GetString(method.ReturnType, settings)); } return(result.ToString()); }
public ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier) { ResolveResult result = null; if (resultTable.TryGetValue (identifier, out result)) return result; resultTable[identifier] = result; foreach (KeyValuePair<string, List<LocalLookupVariable>> pair in this.lookupTableVisitor.Variables) { if (identifier == pair.Key) { LocalLookupVariable var = null; // Console.WriteLine ("--- RP:" + this.resolvePosition + "/" + pair.Value.Count); foreach (LocalLookupVariable v2 in pair.Value) { DomLocation varStartPos = new DomLocation (lookupVariableLine + v2.StartPos.Line, v2.StartPos.Column - 1); DomLocation varEndPos = new DomLocation (lookupVariableLine + v2.EndPos.Line, v2.EndPos.Column - 1); // Console.WriteLine (v2.Name + ":" + varStartPos + " <> " + varEndPos); if (varStartPos > this.resolvePosition || (!v2.EndPos.IsEmpty && varEndPos < this.resolvePosition)) continue; var = v2; } // Console.WriteLine ("var:" + var); if (var == null) continue; IReturnType varType = null; IReturnType varTypeUnresolved = null; if (var.IsQueryContinuation) { QueryExpression query = var.Initializer as QueryExpression; QueryExpressionGroupClause grouBy = query.SelectOrGroupClause as QueryExpressionGroupClause; DomLocation old = resolvePosition; try { resolvePosition = new DomLocation (lookupVariableLine + grouBy.Projection.StartLocation.Line, grouBy.Projection.StartLocation.Column); ResolveResult initializerResolve = visitor.Resolve (grouBy.Projection); ResolveResult groupByResolve = visitor.Resolve (grouBy.GroupBy); DomReturnType resolved = new DomReturnType (dom.GetType ("System.Linq.IGrouping", new IReturnType [] { DomType.GetComponentType (dom, initializerResolve.ResolvedType), groupByResolve.ResolvedType})); varTypeUnresolved = varType = resolved; } finally { resolvePosition = old; } } else if ((var.TypeRef == null || var.TypeRef.Type == "var" || var.TypeRef.IsNull)) { if (var.ParentLambdaExpression != null) { ResolveResult lambdaResolve = ResolveLambda (visitor, var.ParentLambdaExpression); if (lambdaResolve != null) { varType = lambdaResolve.ResolvedType; varTypeUnresolved = lambdaResolve.UnresolvedType; } else { varType = varTypeUnresolved = DomReturnType.Void; } } if (var.Initializer != null) { ResolveResult initializerResolve = visitor.Resolve (var.Initializer); // Console.WriteLine ("initializer : "+ var.Initializer + " result:" + initializerResolve); varType = var.IsLoopVariable ? DomType.GetComponentType (dom, initializerResolve.ResolvedType) : initializerResolve.ResolvedType; varTypeUnresolved = var.IsLoopVariable ? DomType.GetComponentType (dom, initializerResolve.UnresolvedType) : initializerResolve.UnresolvedType; // Console.WriteLine ("resolved type:" + initializerResolve.ResolvedType + " is loop : " + var.IsLoopVariable); // Console.WriteLine (varType); // Console.WriteLine ("----------"); } } else { varTypeUnresolved = varType = ConvertTypeReference (var.TypeRef); } // Console.WriteLine ("-----"); // Console.WriteLine (varType); varType = ResolveType (varType); result = new LocalVariableResolveResult ( new LocalVariable (CallingMember, identifier, varType, new DomRegion (lookupVariableLine + var.StartPos.Line - 1, var.StartPos.Column - 1, lookupVariableLine + var.StartPos.Line - 1, var.EndPos.Column - 1)), var.IsLoopVariable); result.ResolvedType = varType; result.UnresolvedType = varTypeUnresolved; goto end; } } if (this.callingMember != null) { // special handling of property or field return types, they can have the same name as the return type // ex.: MyType MyType { get; set; } Type1 Type1; if ((callingMember is IProperty || callingMember is IField) && identifier == callingMember.Name) { int pos = editor.GetPositionFromLineColumn (resolvePosition.Line, resolvePosition.Column); while (pos < editor.TextLength && !Char.IsWhiteSpace (editor.GetCharAt (pos))) pos++; while (pos < editor.TextLength && Char.IsWhiteSpace (editor.GetCharAt (pos))) pos++; StringBuilder memberName = new StringBuilder (); while (pos < editor.TextLength && (Char.IsLetterOrDigit (editor.GetCharAt (pos)) || editor.GetCharAt (pos) == '_') ) { memberName.Append (editor.GetCharAt (pos)); pos++; } //Console.WriteLine ("id: '" + identifier + "' : '" + memberName.ToString () +"'" + (memberName.ToString () == identifier)); if (memberName.ToString () == identifier) { result = visitor.CreateResult (callingMember.ReturnType); goto end; } } if (identifier == "value" && this.callingMember is IProperty) { result = new MemberResolveResult (this.callingMember); result.UnresolvedType = ((IProperty)this.callingMember).ReturnType; result.ResolvedType = ResolveType (((IProperty)this.callingMember).ReturnType); goto end; } if (this.callingMember is IMethod || this.callingMember is IProperty) { ReadOnlyCollection<IParameter> prms = this.callingMember is IMethod ? ((IMethod)this.callingMember).Parameters : ((IProperty)this.callingMember).Parameters; if (prms != null) { foreach (IParameter para in prms) { if (para.Name == identifier) { result = new ParameterResolveResult (para); result.UnresolvedType = para.ReturnType; result.ResolvedType = ResolveType (para.ReturnType); goto end; } } } } } IType searchedType = dom.SearchType (new SearchTypeRequest (unit, this.CallingType, identifier)); if (this.callingType != null && dom != null) { List<IMember> members = new List <IMember> (); foreach (IType type in dom.GetInheritanceTree (callingType)) { members.AddRange (type.SearchMember (identifier, true)); } bool includeProtected = true; // filter members if (this.CallingMember != null) { for (int i = 0; i < members.Count; i++) { if (this.CallingMember.IsStatic && !members[i].IsStatic || !members[i].IsAccessibleFrom (dom, callingType, this.CallingMember, includeProtected)) { members.RemoveAt (i); i--; continue; } } } if (members.Count > 0) { if (members[0] is IMethod) { result = new MethodResolveResult (members); if (CallingMember != null) result.StaticResolve = CallingMember.IsStatic; } else if (members[0] is IType) { result = new MemberResolveResult (null, true); result.UnresolvedType = result.ResolvedType = new DomReturnType ((IType)members[0]); goto end; } else { result = new MemberResolveResult (members[0]); } result.UnresolvedType = members[0].ReturnType; result.ResolvedType = ResolveType (members[0].ReturnType); if (members[0] is IProperty && searchedType != null && result.ResolvedType.FullName == searchedType.FullName) { result = new AggregatedResolveResult (result, new MemberResolveResult (null, true) { UnresolvedType = new DomReturnType (searchedType), ResolvedType = new DomReturnType (searchedType) }); } goto end; } } if (searchedType != null) { result = new MemberResolveResult (null, true); result.UnresolvedType = result.ResolvedType = new DomReturnType (searchedType); goto end; } if (dom.NamespaceExists (identifier, true)) { result = new NamespaceResolveResult (identifier); goto end; } if (unit != null && unit.Usings != null) { foreach (IUsing u in unit.Usings) { if (u.IsFromNamespace && u.Region.Contains (resolvePosition)) { foreach (string ns in u.Namespaces) { if (dom.NamespaceExists (ns + "." + identifier, true)) { result = new NamespaceResolveResult (ns + "." + identifier); goto end; } } } foreach (KeyValuePair<string, IReturnType> alias in u.Aliases) { if (alias.Key == identifier || alias.Key + ".?" == identifier) { result = new NamespaceResolveResult (alias.Value.FullName); goto end; } } } } end: if (result != null) { result.CallingType = CallingType; result.CallingMember = CallingMember; } resultTable[identifier] = result; return result; }
public IType ImplementInterface(ICompilationUnit pinfo, IType klass, IType iface, bool explicitly, IType declaringClass, IReturnType hintReturnType) { if (klass == null) { throw new ArgumentNullException("klass"); } if (iface == null) { throw new ArgumentNullException("iface"); } RefactorerContext gctx = GetGeneratorContext(klass); klass = GetUpdatedClass(gctx, klass); bool alreadyImplemented; IReturnType prefix = null; List <KeyValuePair <IMember, IReturnType> > toImplement = new List <KeyValuePair <IMember, IReturnType> > (); prefix = new DomReturnType(iface); // Stub out non-implemented events defined by @iface foreach (IEvent ev in iface.Events) { if (ev.IsSpecialName) { continue; } bool needsExplicitly = explicitly; alreadyImplemented = gctx.ParserContext.GetInheritanceTree(klass).Any(x => x.ClassType != ClassType.Interface && x.Events.Any(y => y.Name == ev.Name)); if (!alreadyImplemented) { toImplement.Add(new KeyValuePair <IMember, IReturnType> (ev, needsExplicitly ? prefix : null)); } } // Stub out non-implemented methods defined by @iface foreach (IMethod method in iface.Methods) { if (method.IsSpecialName) { continue; } bool needsExplicitly = explicitly; alreadyImplemented = false; foreach (IType t in gctx.ParserContext.GetInheritanceTree(klass)) { if (t.ClassType == ClassType.Interface) { continue; } foreach (IMethod cmet in t.Methods) { if (cmet.Name == method.Name && Equals(cmet.Parameters, method.Parameters)) { if (!needsExplicitly && !cmet.ReturnType.Equals(method.ReturnType)) { needsExplicitly = true; } else { alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix(cmet.ExplicitInterfaces)); } } } } if (!alreadyImplemented) { toImplement.Add(new KeyValuePair <IMember, IReturnType> (method, needsExplicitly ? prefix : null)); } } // Stub out non-implemented properties defined by @iface foreach (IProperty prop in iface.Properties) { if (prop.IsSpecialName) { continue; } bool needsExplicitly = explicitly; alreadyImplemented = false; foreach (IType t in gctx.ParserContext.GetInheritanceTree(klass)) { if (t.ClassType == ClassType.Interface) { continue; } foreach (IProperty cprop in t.Properties) { if (cprop.Name == prop.Name) { if (!needsExplicitly && !cprop.ReturnType.Equals(prop.ReturnType)) { needsExplicitly = true; } else { alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix(cprop.ExplicitInterfaces)); } } } } if (!alreadyImplemented) { toImplement.Add(new KeyValuePair <IMember, IReturnType> (prop, needsExplicitly ? prefix : null)); } } Ambience ambience = AmbienceService.GetAmbienceForFile(klass.CompilationUnit.FileName); //implement members ImplementMembers(klass, toImplement, ambience.GetString(iface, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters) + " implementation"); gctx.Save(); klass = GetUpdatedClass(gctx, klass); foreach (IType baseClass in iface.SourceProjectDom.GetInheritanceTree(iface)) { if (baseClass.Equals(iface) || baseClass.FullName == "System.Object") { continue; } klass = ImplementInterface(pinfo, klass, baseClass, explicitly, declaringClass, hintReturnType); } return(klass); }
public ResolveResult ResolveIdentifier(ResolveVisitor visitor, string identifier) { ResolveResult result = null; if (resultTable.TryGetValue(identifier, out result)) { return(result); } resultTable[identifier] = result; // Console.WriteLine (lookupVariableLine); foreach (KeyValuePair <string, List <LocalLookupVariable> > pair in this.lookupTableVisitor.Variables) { if (identifier == pair.Key) { LocalLookupVariable var = null; // Console.WriteLine ("--- RP:" + this.resolvePosition + "/" + pair.Value.Count); foreach (LocalLookupVariable v2 in pair.Value) { DomLocation varStartPos = new DomLocation(lookupVariableLine + v2.StartPos.Line, v2.StartPos.Column - 1); DomLocation varEndPos = new DomLocation(lookupVariableLine + v2.EndPos.Line, v2.EndPos.Column - 1); // Console.WriteLine (v2.Name + ":" + varStartPos + " <> " + varEndPos + " resolve position:" + this.resolvePosition); if (varStartPos > this.resolvePosition || (!v2.EndPos.IsEmpty && varEndPos < this.resolvePosition)) { continue; } var = v2; } // Console.WriteLine ("var:" + var); if (var == null) { continue; } IReturnType varType = null; IReturnType varTypeUnresolved = null; if (var.IsQueryContinuation) { QueryExpression query = var.Initializer as QueryExpression; QueryExpressionGroupClause grouBy = query.SelectOrGroupClause as QueryExpressionGroupClause; DomLocation old = resolvePosition; try { resolvePosition = new DomLocation(lookupVariableLine + grouBy.Projection.StartLocation.Line, grouBy.Projection.StartLocation.Column); ResolveResult initializerResolve = visitor.Resolve(grouBy.Projection); ResolveResult groupByResolve = visitor.Resolve(grouBy.GroupBy); DomReturnType resolved = new DomReturnType(dom.GetType("System.Linq.IGrouping", new IReturnType [] { DomType.GetComponentType(dom, initializerResolve.ResolvedType), groupByResolve.ResolvedType })); varTypeUnresolved = varType = resolved; } finally { resolvePosition = old; } } else if ((var.TypeRef == null || var.TypeRef.Type == "var" || var.TypeRef.IsNull)) { if (var.ParentLambdaExpression != null) { ResolveResult lambdaResolve = ResolveLambda(visitor, var.ParentLambdaExpression); if (lambdaResolve != null) { varType = lambdaResolve.ResolvedType; varTypeUnresolved = lambdaResolve.UnresolvedType; IType type = Dom.GetType(varType); if (type != null && type.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate) { IMethod invocationMethod = type.Methods.First(); if (invocationMethod.Parameters.Count > 0) { varType = varTypeUnresolved = invocationMethod.Parameters[0].ReturnType; } } } else { varType = varTypeUnresolved = DomReturnType.Void; } } if (var.Initializer != null) { ResolveResult initializerResolve = visitor.Resolve(var.Initializer); // Console.WriteLine ("initializer : "+ var.Initializer + " result:" + initializerResolve); varType = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.ResolvedType) : initializerResolve.ResolvedType; varTypeUnresolved = var.IsLoopVariable ? DomType.GetComponentType(dom, initializerResolve.UnresolvedType) : initializerResolve.UnresolvedType; // Console.WriteLine ("resolved type:" + initializerResolve.ResolvedType + " is loop : " + var.IsLoopVariable); // Console.WriteLine (varType); // Console.WriteLine ("----------"); } } else { varTypeUnresolved = varType = ConvertTypeReference(var.TypeRef); } varType = ResolveType(varType); result = new LocalVariableResolveResult( new LocalVariable(CallingMember, identifier, varType, new DomRegion(lookupVariableLine + var.StartPos.Line, var.StartPos.Column, lookupVariableLine + var.StartPos.Line, var.EndPos.Column)), var.IsLoopVariable); result.ResolvedType = varType; result.UnresolvedType = varTypeUnresolved; goto end; } } if (this.callingMember != null) { // special handling of property or field return types, they can have the same name as the return type // ex.: MyType MyType { get; set; } Type1 Type1; if ((callingMember is IProperty || callingMember is IField) && identifier == callingMember.Name) { int pos = editor.GetPositionFromLineColumn(resolvePosition.Line, resolvePosition.Column); while (pos < editor.TextLength && !Char.IsWhiteSpace(editor.GetCharAt(pos))) { pos++; } while (pos < editor.TextLength && Char.IsWhiteSpace(editor.GetCharAt(pos))) { pos++; } StringBuilder memberName = new StringBuilder(); while (pos < editor.TextLength && (Char.IsLetterOrDigit(editor.GetCharAt(pos)) || editor.GetCharAt(pos) == '_')) { memberName.Append(editor.GetCharAt(pos)); pos++; } //Console.WriteLine ("id: '" + identifier + "' : '" + memberName.ToString () +"'" + (memberName.ToString () == identifier)); if (memberName.ToString() == identifier) { result = visitor.CreateResult(callingMember.ReturnType); goto end; } } if (identifier == "value" && this.callingMember is IProperty) { result = new MemberResolveResult(this.callingMember); result.UnresolvedType = ((IProperty)this.callingMember).ReturnType; result.ResolvedType = ResolveType(((IProperty)this.callingMember).ReturnType); goto end; } if (this.callingMember is IMethod || this.callingMember is IProperty) { ReadOnlyCollection <IParameter> prms = this.callingMember is IMethod ? ((IMethod)this.callingMember).Parameters : ((IProperty)this.callingMember).Parameters; if (prms != null) { foreach (IParameter para in prms) { if (para.Name == identifier) { result = new ParameterResolveResult(para); result.UnresolvedType = para.ReturnType; result.ResolvedType = ResolveType(para.ReturnType); goto end; } } } } } IType searchedType = SearchType(identifier); if (this.callingType != null && dom != null) { List <IMember> members = new List <IMember> (); foreach (IType type in dom.GetInheritanceTree(callingType)) { members.AddRange(type.SearchMember(identifier, true)); } bool includeProtected = true; // filter members if (this.CallingMember != null) { for (int i = 0; i < members.Count; i++) { if (this.CallingMember.IsStatic && !members[i].IsStatic || !members[i].IsAccessibleFrom(dom, callingType, this.CallingMember, includeProtected)) { members.RemoveAt(i); i--; continue; } } } if (members.Count > 0) { if (members[0] is IMethod) { result = new MethodResolveResult(members); if (CallingMember != null) { result.StaticResolve = CallingMember.IsStatic; } } else if (members[0] is IType) { result = new MemberResolveResult(null, true); result.UnresolvedType = result.ResolvedType = new DomReturnType((IType)members[0]); goto end; } else { result = new MemberResolveResult(members[0]); } result.UnresolvedType = members[0].ReturnType; result.ResolvedType = ResolveType(members[0].ReturnType); if (members[0] is IProperty && searchedType != null && result.ResolvedType.FullName == searchedType.FullName) { result = new AggregatedResolveResult(result, new MemberResolveResult(null, true) { UnresolvedType = new DomReturnType(searchedType), ResolvedType = new DomReturnType(searchedType) }); } goto end; } } if (searchedType != null) { result = new MemberResolveResult(null, true); result.UnresolvedType = result.ResolvedType = new DomReturnType(searchedType); goto end; } if (dom.NamespaceExists(identifier, true)) { result = new NamespaceResolveResult(identifier); goto end; } if (unit != null && unit.Usings != null) { foreach (IUsing u in unit.Usings) { if (u.IsFromNamespace && u.Region.Contains(resolvePosition)) { foreach (string ns in u.Namespaces) { if (dom.NamespaceExists(ns + "." + identifier, true)) { result = new NamespaceResolveResult(ns + "." + identifier); goto end; } } } foreach (KeyValuePair <string, IReturnType> alias in u.Aliases) { if (alias.Key == identifier || alias.Key + ".?" == identifier) { result = new NamespaceResolveResult(alias.Value.FullName); goto end; } } } } end: if (result != null) { result.CallingType = CallingType; result.CallingMember = CallingMember; } resultTable[identifier] = result; return(result); }
ResolveResult CreateResult (ICompilationUnit unit, IReturnType type) { MemberResolveResult result = new MemberResolveResult (null); result.CallingType = resolver.CallingType; result.CallingMember = resolver.CallingMember; result.ResolvedType = type; result.UnresolvedType = type; if (unit != null && resolver.Dom != null && type != null && type.Type == null) { IType searchedType = resolver.SearchType (type); if (searchedType != null) { DomReturnType resType = new DomReturnType (searchedType); resType.ArrayDimensions = type.ArrayDimensions; for (int i = 0; i < type.ArrayDimensions; i++) { resType.SetDimension (i, type.GetDimension (i)); } resType.PointerNestingLevel = type.PointerNestingLevel; result.ResolvedType = resType; } } return result; }
public void ReadWriteReturnTypeTest () { DomReturnType input = new DomReturnType (); input.Name = "Test"; input.Namespace = "Namespace"; input.ArrayDimensions = 5; input.IsByRef = true; input.IsNullable = true; input.PointerNestingLevel = 666; input.AddTypeParameter (new DomReturnType ("System.String")); input.AddTypeParameter (new DomReturnType ("System.Int32")); MemoryStream ms = new MemoryStream (); BinaryWriter writer = new BinaryWriter (ms); DomPersistence.Write (writer, DefaultNameEncoder, input); byte[] bytes = ms.ToArray (); IReturnType result = DomPersistence.ReadReturnType (CreateReader (bytes), DefaultNameDecoder); Assert.AreEqual ("Test", result.Name); Assert.AreEqual ("Namespace", result.Namespace); Assert.AreEqual ("Namespace.Test", result.FullName); Assert.AreEqual (5, result.ArrayDimensions); Assert.AreEqual (true, result.IsByRef); Assert.AreEqual (true, result.IsNullable); Assert.AreEqual ("System.String", result.GenericArguments[0].FullName); Assert.AreEqual ("System.Int32", result.GenericArguments[1].FullName); }
public ExtensionMethod (IType extensionType, IMethod originalMethod, IList<IReturnType> genericArguments, IEnumerable<IReturnType> methodArguments) { if (extensionType == null) throw new ArgumentNullException ("extensionType"); if (originalMethod == null) throw new ArgumentNullException ("originalMethod"); this.DeclaringType = extensionType; List<IReturnType> args = new List<IReturnType> (); if (extensionType.FullName.EndsWith ("[]")) { foreach (IReturnType returnType in extensionType.BaseTypes) { if (returnType.FullName == "System.Collections.Generic.IList" && returnType.GenericArguments.Count > 0) { args.Add (returnType.GenericArguments[0]); break; } } if (args.Count == 0) args.Add (new DomReturnType (extensionType)); } else if (extensionType is InstantiatedType) { InstantiatedType instType = (InstantiatedType)extensionType; DomReturnType uninstantiatedReturnType = new DomReturnType (instType.UninstantiatedType.FullName); foreach (IReturnType genArg in instType.GenericParameters) { uninstantiatedReturnType.AddTypeParameter (genArg); } args.Add (uninstantiatedReturnType); } else { args.Add (new DomReturnType (extensionType)); } if (methodArguments != null) args.AddRange (methodArguments); // Console.WriteLine ("Create Extension method from:"); // Console.WriteLine ("ext type:" + args[0]); // Console.WriteLine (originalMethod); this.method = DomMethod.CreateInstantiatedGenericMethod (originalMethod, genericArguments, args); // skip first parameter. for (int i = 1; i < method.Parameters.Count; i++) { Add (method.Parameters[i]); } foreach (ITypeParameter par in method.TypeParameters) { AddTypeParameter (par); } this.ExtensionType = extensionType; this.OriginalMethod = originalMethod; //Console.WriteLine (this); //Console.WriteLine ("oOoOoOoOoOoOoOoOoOoOoOoOoOoO"); }
public static DomReturnType ConvertToReturnType(this AstType typeRef) { if (typeRef == null) { return(null); } DomReturnType result; if (typeRef is SimpleType) { var st = (SimpleType)typeRef; result = new DomReturnType(st.Identifier); foreach (var arg in st.TypeArguments) { result.AddTypeParameter(ConvertToReturnType(arg)); } } else if (typeRef is ICSharpCode.NRefactory.CSharp.MemberType) { var mt = (ICSharpCode.NRefactory.CSharp.MemberType)typeRef; result = ConvertToReturnType(mt.Target); result.Parts.Add(new ReturnTypePart(mt.MemberName)); foreach (var arg in mt.TypeArguments) { result.AddTypeParameter(ConvertToReturnType(arg)); } } else if (typeRef is ComposedType) { var ct = (ComposedType)typeRef; result = ConvertToReturnType(ct.BaseType); result.PointerNestingLevel = ct.PointerRank; result.IsNullable = ct.HasNullableSpecifier; int arraySpecifiers = ct.ArraySpecifiers.Count; if (arraySpecifiers > 0) { result.ArrayDimensions = arraySpecifiers; int i = 0; foreach (var spec in ct.ArraySpecifiers) { result.SetDimension(i, spec.Dimensions); i++; } } } else if (typeRef is PrimitiveType) { var pt = (PrimitiveType)typeRef; result = new DomReturnType(pt.Keyword); } else if (typeRef.IsNull) { return(null); } else { throw new InvalidOperationException("unknown AstType:" + typeRef); } return(result); }
public static DomReturnType ConvertToReturnType (this AstType typeRef) { if (typeRef == null) return null; DomReturnType result; if (typeRef is SimpleType) { var st = (SimpleType)typeRef; result = new DomReturnType (st.Identifier); foreach (var arg in st.TypeArguments){ result.AddTypeParameter (ConvertToReturnType (arg)); } } else if (typeRef is ICSharpCode.NRefactory.CSharp.MemberType) { var mt = (ICSharpCode.NRefactory.CSharp.MemberType)typeRef; result = ConvertToReturnType (mt.Target); result.Parts.Add (new ReturnTypePart (mt.MemberName)); foreach (var arg in mt.TypeArguments){ result.AddTypeParameter (ConvertToReturnType (arg)); } } else if (typeRef is ComposedType) { var ct = (ComposedType)typeRef; result = ConvertToReturnType (ct.BaseType); result.PointerNestingLevel = ct.PointerRank; result.IsNullable = ct.HasNullableSpecifier; int arraySpecifiers = ct.ArraySpecifiers.Count; if (arraySpecifiers> 0) { result.ArrayDimensions = arraySpecifiers; int i = 0; foreach (var spec in ct.ArraySpecifiers) { result.SetDimension (i, spec.Dimensions); i++; } } } else if (typeRef is PrimitiveType) { var pt = (PrimitiveType)typeRef; result = new DomReturnType (pt.Keyword); } else if (typeRef.IsNull) { return null; } else { throw new InvalidOperationException ("unknown AstType:" + typeRef); } return result; }
public override ICompletionDataList HandleCodeCompletion (CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength) { if (textEditorData.CurrentMode is CompletionTextLinkMode) { if (!((CompletionTextLinkMode)textEditorData.CurrentMode).TriggerCodeCompletion) return null; } else if (textEditorData.CurrentMode is Mono.TextEditor.TextLinkEditMode) { return null; } // IDisposable timer = null; try { if (dom == null /*|| Document.CompilationUnit == null*/) return null; if (completionChar != '#' && stateTracker.Engine.IsInsidePreprocessorDirective) return null; // timer = Counters.ResolveTime.BeginTiming (); DomLocation location = new DomLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset - 1); stateTracker.UpdateEngine (); ExpressionResult result; int cursor, newCursorOffset = 0; switch (completionChar) { case ':': case '.': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext); if (result == null || result.Expression == null) return null; int idx = result.Expression.LastIndexOf ('.'); if (idx > 0) result.Expression = result.Expression.Substring (0, idx); // don't parse expressions that end with more than 1 dot - see #646820 if (result.Expression.EndsWith (".")) return null; NRefactoryResolver resolver = CreateResolver (); ResolveResult resolveResult = resolver.Resolve (result, location); if (resolver.ResolvedExpression is ICSharpCode.NRefactory.Ast.PrimitiveExpression) { ICSharpCode.NRefactory.Ast.PrimitiveExpression pex = (ICSharpCode.NRefactory.Ast.PrimitiveExpression)resolver.ResolvedExpression; if (!tryToForceCompletion && !(pex.Value is string || pex.Value is char || pex.Value is bool)) return null; } return CreateCompletionData (location, resolveResult, result, resolver); case '#': if (stateTracker.Engine.IsInsidePreprocessorDirective) return GetDirectiveCompletionData (); return null; case '>': cursor = textEditorData.IsSomethingSelected ? textEditorData.SelectionRange.Offset : textEditorData.Caret.Offset; if (stateTracker.Engine.IsInsideDocLineComment) { string lineText = textEditorData.GetLineText (completionContext.TriggerLine); int startIndex = Math.Min (completionContext.TriggerLineOffset - 1, lineText.Length - 1); while (startIndex >= 0 && lineText[startIndex] != '<') { --startIndex; if (lineText[startIndex] == '/') { // already closed. startIndex = -1; break; } } if (startIndex >= 0) { int endIndex = startIndex; while (endIndex <= completionContext.TriggerLineOffset && endIndex < lineText.Length && !Char.IsWhiteSpace (lineText[endIndex])) { endIndex++; } string tag = endIndex - startIndex - 1 > 0 ? lineText.Substring (startIndex + 1, endIndex - startIndex - 2) : null; if (!String.IsNullOrEmpty (tag) && commentTags.IndexOf (tag) >= 0) { textEditorData.Insert (cursor, "</" + tag + ">"); textEditorData.Caret.Offset = cursor; return null; } } } return null; /* Disabled because it gives problems when declaring arrays - for example string [] should not pop up code completion. case '[': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext); if (result.ExpressionContext == ExpressionContext.Attribute) return CreateCtrlSpaceCompletionData (completionContext, result); return null;*/ case '<': if (stateTracker.Engine.IsInsideDocLineComment) return GetXmlDocumentationCompletionData (); return null; case '(': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext, -1); if (result == null || result.Expression == null) return null; resolver = CreateResolver (); resolveResult = resolver.Resolve (result, new DomLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset - 2)); if (resolveResult != null && resolver.ResolvedExpression is ICSharpCode.NRefactory.Ast.TypeOfExpression) { CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector col = new CompletionDataCollector (dom, completionList, Document.CompilationUnit, resolver.CallingType, location); AddPrimitiveTypes (col); foreach (object o in dom.GetNamespaceContents (GetUsedNamespaces (), true, true)) { col.Add (o); } if (resolver.CallingMember is IMethod) { foreach (ITypeParameter tp in ((IMethod)resolver.CallingMember).TypeParameters) { col.Add (tp.Name, "md-keyword"); } } if (resolver.CallingType != null) { foreach (ITypeParameter tp in resolver.CallingType.TypeParameters) { col.Add (tp.Name, "md-keyword"); } } return completionList; } return null; case '/': cursor = textEditorData.IsSomethingSelected ? textEditorData.SelectionRange.Offset : textEditorData.Caret.Offset; if (cursor < 2) break; if (stateTracker.Engine.IsInsideDocLineComment) { string lineText = textEditorData.GetLineText (completionContext.TriggerLine); bool startsDocComment = true; int slashes = 0; for (int i = 0; i < completionContext.TriggerLineOffset && i < lineText.Length; i++) { if (lineText[i] == '/') { slashes++; continue; } if (!Char.IsWhiteSpace (lineText[i])) { startsDocComment = false; break; } } // check if lines above already start a doc comment for (int i = completionContext.TriggerLine - 2; i >= 1; i--) { string text = textEditorData.GetLineText (i); if (text.Length == 0) continue; if (text.StartsWith ("///")) { startsDocComment = false; break; } break; } // check if following lines start a doc comment for (int i = completionContext.TriggerLine; i <= textEditorData.Document.LineCount; i++) { string text = textEditorData.GetLineText (i); if (text == null) break; text = text.Trim (); if (text.Length == 0) continue; if (text.StartsWith ("///")) { startsDocComment = false; break; } break; } if (!startsDocComment || slashes != 3) break; StringBuilder generatedComment = new StringBuilder (); bool generateStandardComment = true; ParsedDocument currentParsedDocument = Document.UpdateParseDocument (); IType insideClass = NRefactoryResolver.GetTypeAtCursor (currentParsedDocument.CompilationUnit, Document.FileName, location); if (insideClass != null) { string indent = textEditorData.Document.GetLineIndent (completionContext.TriggerLine); if (insideClass.ClassType == ClassType.Delegate) { AppendSummary (generatedComment, indent, out newCursorOffset); IMethod m = null; foreach (IMethod method in insideClass.Methods) m = method; AppendMethodComment (generatedComment, indent, m); generateStandardComment = false; } else { if (!IsInsideClassBody (insideClass, completionContext.TriggerLine, completionContext.TriggerLineOffset)) break; string body = GenerateBody (insideClass, completionContext.TriggerLine, indent, out newCursorOffset); if (!String.IsNullOrEmpty (body)) { generatedComment.Append (body); generateStandardComment = false; } } } if (generateStandardComment) { string indent = textEditorData.Document.GetLineIndent (completionContext.TriggerLine); AppendSummary (generatedComment, indent, out newCursorOffset); } textEditorData.Document.EndAtomicUndo (); textEditorData.Document.BeginAtomicUndo (); textEditorData.Insert (cursor, generatedComment.ToString ()); textEditorData.Caret.Offset = cursor + newCursorOffset; return null; } return null; // case '\n': // case '\r': { // if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) // return null; // result = FindExpression (dom, completionContext); // if (result == null) // return null; // // // int tokenIndex = completionContext.TriggerOffset; // string token = GetPreviousToken (ref tokenIndex, false); // if (result.ExpressionContext == ExpressionContext.ObjectInitializer) { // if (token == "{" || token == ",") // return CreateCtrlSpaceCompletionData (completionContext, result); // } // return null; // } case ' ': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext); if (result == null) return null; int tokenIndex = completionContext.TriggerOffset; string token = GetPreviousToken (ref tokenIndex, false); if (result.ExpressionContext == ExpressionContext.ObjectInitializer) { resolver = CreateResolver (); ExpressionContext exactContext = new NewCSharpExpressionFinder (dom).FindExactContextForObjectInitializer (textEditorData, resolver.Unit, Document.FileName, resolver.CallingType); IReturnType objectInitializer = ((ExpressionContext.TypeExpressionContext)exactContext).UnresolvedType; if (objectInitializer != null && objectInitializer.ArrayDimensions == 0 && objectInitializer.PointerNestingLevel == 0 && (token == "{" || token == ",")) return CreateCtrlSpaceCompletionData (completionContext, result); } if (token == "=") { int j = tokenIndex; string prevToken = GetPreviousToken (ref j, false); if (prevToken == "=" || prevToken == "+" || prevToken == "-") { token = prevToken + token; tokenIndex = j; } } switch (token) { case "=": case "==": result = FindExpression (dom, completionContext, tokenIndex - completionContext.TriggerOffset - 1); resolver = CreateResolver (); resolveResult = resolver.Resolve (result, location); if (resolveResult != null) { IType resolvedType = dom.GetType (resolveResult.ResolvedType); if (resolvedType == null) return null; if (resolvedType.ClassType == ClassType.Enum) { CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector cdc = new CompletionDataCollector (dom, completionList, Document.CompilationUnit, resolver.CallingType, location); IReturnType returnType = new DomReturnType (resolvedType); bool added = false; foreach (IUsing u in Document.CompilationUnit.Usings) { foreach (KeyValuePair<string, IReturnType> alias in u.Aliases) { if (alias.Value.ToInvariantString () == returnType.ToInvariantString ()) { cdc.Add (alias.Key, "md-class"); added = true; } } } if (!added) cdc.Add (returnType);/* foreach (object o in CreateCtrlSpaceCompletionData (completionContext, result)) { MemberCompletionData memberData = o as MemberCompletionData; if (memberData == null || memberData.Member == null) { completionList.Add (o as CompletionData); continue; } if (memberData.Member is IMember) { returnType = ((IMember)memberData.Member).ReturnType; } else if (memberData.Member is IParameter) { returnType = ((IParameter)memberData.Member).ReturnType; } else { returnType = ((LocalVariable)memberData.Member).ReturnType; } // filter out void types if (returnType != null && returnType.FullName != DomReturnType.Void.FullName) completionList.Add (memberData); }*/ completionList.AutoCompleteEmptyMatch = false; resolver.AddAccessibleCodeCompletionData (result.ExpressionContext, cdc); return completionList; } if (resolvedType.FullName == DomReturnType.Bool.FullName) { CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector cdc = new CompletionDataCollector (dom, completionList, Document.CompilationUnit, resolver.CallingType, location); completionList.AutoCompleteEmptyMatch = false; cdc.Add ("true", "md-keyword"); cdc.Add ("false", "md-keyword"); /* foreach (object o in CreateCtrlSpaceCompletionData (completionContext, result)) { MemberCompletionData memberData = o as MemberCompletionData; if (memberData == null || memberData.Member == null) { completionList.Add (o as CompletionData); continue; } IReturnType returnType = null; if (memberData.Member is IMember) { returnType = ((IMember)memberData.Member).ReturnType; } else if (memberData.Member is IParameter) { returnType = ((IParameter)memberData.Member).ReturnType; } else { returnType = ((LocalVariable)memberData.Member).ReturnType; } // filter out void types if (returnType != null && returnType.FullName != DomReturnType.Void.FullName) completionList.Add (memberData); }*/ resolver.AddAccessibleCodeCompletionData (result.ExpressionContext, cdc); return completionList; } if (resolvedType.ClassType == ClassType.Delegate && token == "=") { IMethod delegateMethod = resolvedType.Methods.First (); CompletionDataList completionList = new ProjectDomCompletionDataList (); completionList.Add ("delegate", "md-keyword", GettextCatalog.GetString ("Creates anonymous delegate."), "delegate {" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + "|" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +"};"); StringBuilder sb = new StringBuilder ("("); for (int k = 0; k < delegateMethod.Parameters.Count; k++) { if (k > 0) sb.Append (", "); IType parameterType = dom.GetType (delegateMethod.Parameters[k].ReturnType); IReturnType returnType = parameterType != null ? new DomReturnType (parameterType) : delegateMethod.Parameters[k].ReturnType; sb.Append (CompletionDataCollector.ambience.GetString (Document.CompilationUnit.ShortenTypeName (returnType, textEditorData.Caret.Line, textEditorData.Caret.Column), OutputFlags.ClassBrowserEntries | OutputFlags.UseFullName | OutputFlags.UseFullInnerTypeName)); sb.Append (" "); sb.Append (delegateMethod.Parameters[k].Name); } sb.Append (")"); completionList.Add ("delegate" + sb, "md-keyword", GettextCatalog.GetString ("Creates anonymous delegate."), "delegate" + sb + " {" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + "|" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +"};"); string varName = GetPreviousToken (ref tokenIndex, false); varName = GetPreviousToken (ref tokenIndex, false); if (varName != ".") { varName = null; } else { List<string> names = new List<string> (); while (varName == ".") { varName = GetPreviousToken (ref tokenIndex, false); if (varName == "this") { names.Add ("handle"); } else if (varName != null) { string trimmedName = varName.Trim (); if (trimmedName.Length == 0) break; names.Insert (0, trimmedName); } varName = GetPreviousToken (ref tokenIndex, false); } varName = String.Join ("", names.ToArray ()); foreach (char ch in varName) { if (!char.IsLetterOrDigit (ch) && ch != '_') { varName = ""; break; } } } completionList.Add (new EventCreationCompletionData (textEditorData, varName, resolvedType, null, sb.ToString (), resolver.CallingMember, resolvedType)); return completionList; } } return null; case "+=": case "-=": if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext, tokenIndex - completionContext.TriggerOffset); resolver = CreateResolver (); resolveResult = resolver.Resolve (result, location); if (resolveResult is MemberResolveResult) { MemberResolveResult mrr = resolveResult as MemberResolveResult; IEvent evt = mrr.ResolvedMember as IEvent; if (evt == null) return null; IType delegateType = resolver.SearchType (evt.ReturnType); if (delegateType == null || delegateType.ClassType != ClassType.Delegate) return null; CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector cdc = new CompletionDataCollector (dom, completionList, Document.CompilationUnit, resolver.CallingType, location); IType declaringType = resolver.CallingType; if (Document.LastErrorFreeParsedDocument != null) { declaringType = Document.LastErrorFreeParsedDocument.CompilationUnit.GetType (declaringType.FullName, declaringType.TypeParameters.Count); } IType typeFromDatabase = null; if (declaringType != null) { typeFromDatabase = dom.GetType (declaringType.FullName, new DomReturnType (declaringType).GenericArguments) ?? declaringType; bool includeProtected = DomType.IncludeProtected (dom, typeFromDatabase, resolver.CallingType); foreach (IType type in dom.GetInheritanceTree (typeFromDatabase)) { foreach (IMethod method in type.Methods) { if (method.IsAccessibleFrom (dom, resolver.CallingType, resolver.CallingMember, includeProtected) && MatchDelegate (delegateType, method)) { CompletionData data = cdc.Add (method); data.SetText (data.CompletionText + ";"); } } } } if (token == "+=") { IMethod delegateMethod = delegateType.Methods.First (); completionList.Add ("delegate", "md-keyword", GettextCatalog.GetString ("Creates anonymous delegate."), "delegate {" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + "|" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +"};"); StringBuilder sb = new StringBuilder ("("); for (int k = 0; k < delegateMethod.Parameters.Count; k++) { if (k > 0) sb.Append (", "); IType parameterType = dom.GetType (delegateMethod.Parameters[k].ReturnType); IReturnType returnType = parameterType != null ? new DomReturnType (parameterType) : delegateMethod.Parameters[k].ReturnType; sb.Append (CompletionDataCollector.ambience.GetString (Document.CompilationUnit.ShortenTypeName (returnType, textEditorData.Caret.Line, textEditorData.Caret.Column), OutputFlags.ClassBrowserEntries | OutputFlags.UseFullName | OutputFlags.UseFullInnerTypeName)); sb.Append (" "); sb.Append (delegateMethod.Parameters[k].Name); } sb.Append (")"); completionList.Add ("delegate" + sb, "md-keyword", GettextCatalog.GetString ("Creates anonymous delegate."), "delegate" + sb + " {" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + "|" + Document.Editor.EolMarker + stateTracker.Engine.ThisLineIndent +"};"); string varName = GetPreviousToken (ref tokenIndex, false); varName = GetPreviousToken (ref tokenIndex, false); if (varName != ".") { varName = null; } else { List<string> names = new List<string> (); while (varName == ".") { varName = GetPreviousToken (ref tokenIndex, false); if (varName == "this") { names.Add ("handle"); } else if (varName != null) { string trimmedName = varName.Trim (); if (trimmedName.Length == 0) break; names.Insert (0, trimmedName); } varName = GetPreviousToken (ref tokenIndex, false); } varName = String.Join ("", names.ToArray ()); foreach (char ch in varName) { if (!char.IsLetterOrDigit (ch) && ch != '_') { varName = ""; break; } } } completionList.Add (new EventCreationCompletionData (textEditorData, varName, delegateType, evt, sb.ToString (), resolver.CallingMember, typeFromDatabase)); } return completionList; } return null; } return HandleKeywordCompletion (completionContext, result, tokenIndex, token); default: if ((Char.IsLetter (completionChar) || completionChar == '_') && TextEditorProperties.EnableAutoCodeCompletion && !stateTracker.Engine.IsInsideDocLineComment && !stateTracker.Engine.IsInsideOrdinaryCommentOrString) { char prevCh = completionContext.TriggerOffset > 2 ? textEditorData.GetCharAt (completionContext.TriggerOffset - 2) : '\0'; char nextCh = completionContext.TriggerOffset < textEditorData.Length ? textEditorData.GetCharAt (completionContext.TriggerOffset) : ' '; const string allowedChars = ";,[(){}+-*/%^?:&|~!<>="; if (!Char.IsWhiteSpace (nextCh) && allowedChars.IndexOf (nextCh) < 0) return null; if (Char.IsWhiteSpace (prevCh) || allowedChars.IndexOf (prevCh) >= 0) { result = FindExpression (dom, completionContext, -1); if (result == null) return null; if (IsInLinqContext (result)) { tokenIndex = completionContext.TriggerOffset; token = GetPreviousToken (ref tokenIndex, false); // token last typed token = GetPreviousToken (ref tokenIndex, false); // possible linq keyword ? triggerWordLength = 1; if (linqKeywords.Contains (token)) { if (token == "from") // after from no auto code completion. return null; result.Expression = ""; return CreateCtrlSpaceCompletionData (completionContext, result); } CompletionDataList dataList = new ProjectDomCompletionDataList (); CompletionDataCollector col = new CompletionDataCollector (dom, dataList, Document.CompilationUnit, null, new DomLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset)); foreach (string kw in linqKeywords) { col.Add (kw, "md-keyword"); } return dataList; } else if (result.ExpressionContext != ExpressionContext.IdentifierExpected) { triggerWordLength = 1; bool autoSelect = true; int cpos; if ((prevCh == ',' || prevCh == '(') && GetParameterCompletionCommandOffset (out cpos)) { CodeCompletionContext ctx = CompletionWidget.CreateCodeCompletionContext (cpos); NRefactoryParameterDataProvider provider = ParameterCompletionCommand (ctx) as NRefactoryParameterDataProvider; if (provider != null) { int i = provider.GetCurrentParameterIndex (CompletionWidget, ctx) - 1; if (i < provider.Methods[0].Parameters.Count) { IType returnType = dom.GetType (provider.Methods[0].Parameters[i].ReturnType); autoSelect = returnType == null || returnType.ClassType != ClassType.Delegate; } } } if (result.ExpressionContext == ExpressionContext.TypeName) autoSelect = false; CompletionDataList dataList = CreateCtrlSpaceCompletionData (completionContext, result); dataList.AutoSelect = autoSelect; return dataList; } else { result = FindExpression (dom, completionContext, 0); tokenIndex = completionContext.TriggerOffset; // check foreach case, unfortunately the expression finder is too dumb to handle full type names // should be overworked if the expression finder is replaced with a mcs ast based analyzer. var possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // starting letter possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // varname // read return types to '(' token possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // varType if (possibleForeachToken == ">") { while (possibleForeachToken != "(") possibleForeachToken = GetPreviousToken (ref tokenIndex, false); } else { possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // ( if (possibleForeachToken == ".") while (possibleForeachToken != "(") possibleForeachToken = GetPreviousToken (ref tokenIndex, false); } possibleForeachToken = GetPreviousToken (ref tokenIndex, false); // foreach if (possibleForeachToken == "foreach") { result.ExpressionContext = ExpressionContext.ForeachInToken; } else { return null; // result.ExpressionContext = ExpressionContext.IdentifierExpected; } result.Expression = ""; result.Region = DomRegion.Empty; // identifier has already started with the first letter completionContext.TriggerOffset--; completionContext.TriggerLineOffset--; completionContext.TriggerWordLength = 1; return CreateCtrlSpaceCompletionData (completionContext, result); } } } break; } } catch (Exception e) { LoggingService.LogError ("Unexpected code completion exception." + Environment.NewLine + "FileName: " + Document.FileName + Environment.NewLine + "Position: line=" + completionContext.TriggerLine + " col=" + completionContext.TriggerLineOffset + Environment.NewLine + "Line text: " + Document.Editor.GetLineText (completionContext.TriggerLine), e); } finally { // if (timer != null) // timer.Dispose (); } return null; }
public void GetGenericType () { List<IReturnType> args = new List<IReturnType> (); DomReturnType rt = new DomReturnType ("System.String"); args.Add (rt); IType type = mainProject.GetType ("CompletionDbTest.SomeGeneric", args); Assert.IsNotNull (type); Assert.AreEqual ("CompletionDbTest.SomeGeneric[System.String]", type.FullName); Assert.AreEqual (0, type.TypeParameters.Count); IMethod met = FindMember (type, "Run") as IMethod; Assert.IsNotNull (met); Assert.AreEqual (1, met.Parameters.Count); Assert.AreEqual ("System.String", met.Parameters[0].ReturnType.FullName); Assert.IsNotNull (met.ReturnType); Assert.AreEqual ("System.String", met.ReturnType.FullName); type = mainProject.GetType ("Library2.GenericWidget"); Assert.IsNotNull (type); Assert.AreEqual ("Library2.GenericWidget", type.FullName); Assert.AreEqual (0, type.TypeParameters.Count); type = mainProject.GetType ("Library2.GenericWidget", 1, true); Assert.IsNotNull (type); Assert.AreEqual ("Library2.GenericWidget", type.FullName); Assert.AreEqual (1, type.TypeParameters.Count); type = mainProject.GetType ("Library2.GenericWidget", 2, true); Assert.IsNotNull (type); Assert.AreEqual ("Library2.GenericWidget", type.FullName); Assert.AreEqual (2, type.TypeParameters.Count); type = mainProject.GetType ("Library2.GenericWidget", 3, true); Assert.IsNull (type); // Inner generic type type = mainProject.GetType ("Library2.Container.InnerClass1", 1, true); Assert.IsNotNull (type); }
internal IReturnType GetSharedReturnType(DomReturnType rt) { return(DomReturnType.GetSharedReturnType(rt)); }
public override INode Visit(IReturnType type, IType contextType) { if (type.GenericArguments.Count == 0 && unit != null) { foreach (IUsing u in unit.Usings) { if (u.IsFromNamespace || u.Aliases.Count == 0 && contextType != null && u.Region.Contains(contextType.Location)) { continue; } foreach (KeyValuePair <string, IReturnType> alias in u.Aliases) { if (alias.Key == type.FullName) { return(Visit(alias.Value, contextType)); } } } } if (currentMethod != null) { IMethod method = null; if (currentMethod.IsOverride) { foreach (IType curType2 in db.GetInheritanceTree(contextType)) { foreach (IMethod curMethod in curType2.SearchMember(currentMethod.Name, true)) { if (!curMethod.IsOverride && curMethod.Parameters.Count == currentMethod.Parameters.Count && curMethod.TypeParameters.Count == currentMethod.TypeParameters.Count) { method = curMethod; break; } } if (method != null) { break; } } } if (method == null) { method = currentMethod; } int idx = currentMethod.GetTypeParameterIndex(type.Name); if (idx >= 0) { ITypeParameter t = method.TypeParameters [idx]; DomReturnType typeParameterReturnType = new DomReturnType(type.FullName); DomType constructedType = new InstantiatedParameterType(db, method, t); if (constructedType.BaseType == null) { constructedType.BaseType = DomReturnType.Object; } constructedType.SourceProjectDom = db; typeParameterReturnType.Type = constructedType; typeParameterReturnType.ArrayDimensions = type.ArrayDimensions; typeParameterReturnType.PointerNestingLevel = type.PointerNestingLevel; for (int i = 0; i < type.ArrayDimensions; i++) { typeParameterReturnType.SetDimension(i, type.GetDimension(i)); } return(typeParameterReturnType); } } IType lookupType = db.SearchType(unit, contextType, resolvePosition, type); if (visitAttribute && lookupType == null && type.Parts.Count > 0) { string oldName = type.Parts [type.Parts.Count - 1].Name; type.Parts [type.Parts.Count - 1].Name += "Attribute"; lookupType = db.SearchType(unit, contextType, resolvePosition, type); if (lookupType == null) { type.Parts [type.Parts.Count - 1].Name = oldName; } } if (lookupType == null) { unresolvedCount++; return(type); } List <IReturnTypePart> parts = new List <IReturnTypePart> (type.Parts.Count); IType curType = lookupType.DeclaringType; int typePart = 0; while (curType != null) { ReturnTypePart newPart = new ReturnTypePart { Name = curType.Name }; newPart.IsGenerated = true; for (int n = curType.TypeParameters.Count - 1; n >= 0; n--) { newPart.AddTypeParameter(new DomReturnType("?")); } if (typePart >= type.Parts.Count || (type.Parts [typePart].Name != newPart.Name || type.Parts [typePart].GenericArguments.Count != newPart.GenericArguments.Count)) { parts.Insert(0, newPart); typePart++; } curType = curType.DeclaringType; } foreach (ReturnTypePart part in type.Parts) { ReturnTypePart newPart = new ReturnTypePart(); newPart.Name = part.Name; foreach (IReturnType ga in part.GenericArguments) { newPart.AddTypeParameter((IReturnType)ga.AcceptVisitor(this, contextType)); } parts.Add(newPart); } DomReturnType rt = new DomReturnType(lookupType.Namespace, parts); // Make sure the whole type is resolved if (parts.Count > 1 && db.SearchType(unit, contextType, resolvePosition, rt) == null) { unresolvedCount++; return(type); } rt.PointerNestingLevel = type.PointerNestingLevel; rt.IsNullable = type.IsNullable; rt.ArrayDimensions = type.ArrayDimensions; for (int n = 0; n < type.ArrayDimensions; n++) { rt.SetDimension(n, type.GetDimension(n)); } return(db.GetSharedReturnType(rt)); }
public IType ImplementInterface (ICompilationUnit pinfo, IType klass, IType iface, bool explicitly, IType declaringClass, IReturnType hintReturnType) { if (klass == null) throw new ArgumentNullException ("klass"); if (iface == null) throw new ArgumentNullException ("iface"); RefactorerContext gctx = GetGeneratorContext (klass); klass = GetUpdatedClass (gctx, klass); bool alreadyImplemented; IReturnType prefix = null; List<KeyValuePair<IMember,IReturnType>> toImplement = new List<KeyValuePair<IMember,IReturnType>> (); prefix = new DomReturnType (iface); // Stub out non-implemented events defined by @iface foreach (IEvent ev in iface.Events) { if (ev.IsSpecialName) continue; bool needsExplicitly = explicitly; alreadyImplemented = gctx.ParserContext.GetInheritanceTree (klass).Any (x => x.ClassType != ClassType.Interface && x.Events.Any (y => y.Name == ev.Name)); if (!alreadyImplemented) toImplement.Add (new KeyValuePair<IMember,IReturnType> (ev, needsExplicitly ? prefix : null)); } // Stub out non-implemented methods defined by @iface foreach (IMethod method in iface.Methods) { if (method.IsSpecialName) continue; bool needsExplicitly = explicitly; alreadyImplemented = false; foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) { if (t.ClassType == ClassType.Interface) continue; foreach (IMethod cmet in t.Methods) { if (cmet.Name == method.Name && Equals (cmet.Parameters, method.Parameters)) { if (!needsExplicitly && !cmet.ReturnType.Equals (method.ReturnType)) needsExplicitly = true; else alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cmet.ExplicitInterfaces)); } } } if (!alreadyImplemented) toImplement.Add (new KeyValuePair<IMember,IReturnType> (method, needsExplicitly ? prefix : null)); } // Stub out non-implemented properties defined by @iface foreach (IProperty prop in iface.Properties) { if (prop.IsSpecialName) continue; bool needsExplicitly = explicitly; alreadyImplemented = false; foreach (IType t in gctx.ParserContext.GetInheritanceTree (klass)) { if (t.ClassType == ClassType.Interface) continue; foreach (IProperty cprop in t.Properties) { if (cprop.Name == prop.Name) { if (!needsExplicitly && !cprop.ReturnType.Equals (prop.ReturnType)) needsExplicitly = true; else alreadyImplemented |= !needsExplicitly || (iface.FullName == GetExplicitPrefix (cprop.ExplicitInterfaces)); } } } if (!alreadyImplemented) toImplement.Add (new KeyValuePair<IMember,IReturnType> (prop, needsExplicitly ? prefix : null)); } Ambience ambience = AmbienceService.GetAmbienceForFile (klass.CompilationUnit.FileName); //implement members ImplementMembers (klass, toImplement, ambience.GetString (iface, OutputFlags.ClassBrowserEntries | OutputFlags.IncludeGenerics | OutputFlags.IncludeParameters) + " implementation"); gctx.Save (); klass = GetUpdatedClass (gctx, klass); foreach (IType baseClass in iface.SourceProjectDom.GetInheritanceTree (iface)) { if (baseClass.Equals (iface) || baseClass.FullName == "System.Object") continue; klass = ImplementInterface (pinfo, klass, baseClass, explicitly, declaringClass, hintReturnType); } return klass; }
IReturnType ConvertReturnType (Expression typeName) { if (typeName is TypeExpression) { var typeExpr = (Mono.CSharp.TypeExpression)typeName; if (typeExpr.Type == Mono.CSharp.TypeManager.object_type) return new DomReturnType (DomReturnType.Object.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.string_type) return new DomReturnType (DomReturnType.String.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.int32_type) return new DomReturnType (DomReturnType.Int32.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.uint32_type) return new DomReturnType (DomReturnType.UInt32.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.int64_type) return new DomReturnType (DomReturnType.Int64.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.uint64_type) return new DomReturnType (DomReturnType.UInt64.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.float_type) return new DomReturnType (DomReturnType.Float.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.double_type) return new DomReturnType (DomReturnType.Double.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.char_type) return new DomReturnType (DomReturnType.Char.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.short_type) return new DomReturnType (DomReturnType.Int16.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.decimal_type) return new DomReturnType (DomReturnType.Decimal.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.bool_type) return new DomReturnType (DomReturnType.Bool.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.sbyte_type) return new DomReturnType (DomReturnType.SByte.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.byte_type) return new DomReturnType (DomReturnType.Byte.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.ushort_type) return new DomReturnType (DomReturnType.UInt16.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.void_type) return new DomReturnType (DomReturnType.Void.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.intptr_type) return new DomReturnType (DomReturnType.IntPtr.FullName); if (typeExpr.Type == Mono.CSharp.TypeManager.uintptr_type) return new DomReturnType (DomReturnType.UIntPtr.FullName); MonoDevelop.Core.LoggingService.LogError ("Error while converting :" + typeName + " - unknown type value"); return DomReturnType.Void; } if (typeName is Mono.CSharp.QualifiedAliasMember) { var qam = (Mono.CSharp.QualifiedAliasMember)typeName; // TODO: Overwork the return type model - atm we don't have a good representation // for qualified alias members. return new DomReturnType (qam.Name); } if (typeName is MemberAccess) { MemberAccess ma = (MemberAccess)typeName; var baseType = (DomReturnType)ConvertReturnType (ma.LeftExpression); baseType.Parts.Add (new ReturnTypePart (ma.Name)); AddTypeArguments (ma, baseType); return baseType; } if (typeName is SimpleName) { var sn = (SimpleName)typeName; var result = new DomReturnType (sn.Name); AddTypeArguments (sn, result); return result; } if (typeName is ComposedCast) { var cc = (ComposedCast)typeName; var baseType = (DomReturnType)ConvertReturnType (cc.Left); if (cc.Spec.IsNullable) { return new DomReturnType ("System.Nullable", true, new IReturnType[] { baseType }); } else if (cc.Spec.IsPointer) { baseType.PointerNestingLevel++; } else { baseType.ArrayDimensions++; baseType.SetDimension (baseType.ArrayDimensions - 1, cc.Spec.Dimension - 1); } return baseType; } MonoDevelop.Core.LoggingService.LogError ("Error while converting :" + typeName + " - unknown type name"); return new DomReturnType (DomReturnType.Void.FullName); }
protected override IEnumerable <string> GenerateCode(INRefactoryASTProvider astProvider, string indent, List <IBaseMember> includedMembers) { // Genereate Equals MethodDeclaration methodDeclaration = new MethodDeclaration(); methodDeclaration.Name = "Equals"; methodDeclaration.ReturnType = DomReturnType.Bool.ConvertToTypeReference(); methodDeclaration.Modifiers = ICSharpCode.NRefactory.CSharp.Modifiers.Public | ICSharpCode.NRefactory.CSharp.Modifiers.Override; methodDeclaration.Body = new BlockStatement(); methodDeclaration.Parameters.Add(new ParameterDeclaration(DomReturnType.Object.ConvertToTypeReference(), "obj")); IdentifierExpression paramId = new IdentifierExpression("obj"); IfElseStatement ifStatement = new IfElseStatement(); ifStatement.Condition = new BinaryOperatorExpression(paramId, BinaryOperatorType.Equality, new PrimitiveExpression(null)); ifStatement.TrueStatement = new ReturnStatement(new PrimitiveExpression(false)); methodDeclaration.Body.Statements.Add(ifStatement); ifStatement = new IfElseStatement(); List <Expression> arguments = new List <Expression> (); arguments.Add(new ThisReferenceExpression()); arguments.Add(paramId.Clone()); ifStatement.Condition = new InvocationExpression(new IdentifierExpression("ReferenceEquals"), arguments); ifStatement.TrueStatement = new ReturnStatement(new PrimitiveExpression(true)); methodDeclaration.Body.Statements.Add(ifStatement); ifStatement = new IfElseStatement(); ifStatement.Condition = new BinaryOperatorExpression(new InvocationExpression(new MemberReferenceExpression(paramId.Clone(), "GetType")), BinaryOperatorType.InEquality, new TypeOfExpression(new SimpleType(Options.EnclosingType.Name))); ifStatement.TrueStatement = new ReturnStatement(new PrimitiveExpression(false)); methodDeclaration.Body.Statements.Add(ifStatement); AstType varType = new DomReturnType(Options.EnclosingType).ConvertToTypeReference(); var varDecl = new VariableDeclarationStatement(varType, "other", new CastExpression(varType.Clone(), paramId.Clone())); methodDeclaration.Body.Statements.Add(varDecl); IdentifierExpression otherId = new IdentifierExpression("other"); Expression binOp = null; foreach (IMember member in includedMembers) { Expression right = new BinaryOperatorExpression(new IdentifierExpression(member.Name), BinaryOperatorType.Equality, new MemberReferenceExpression(otherId, member.Name)); if (binOp == null) { binOp = right; } else { binOp = new BinaryOperatorExpression(binOp, BinaryOperatorType.ConditionalAnd, right); } } methodDeclaration.Body.Statements.Add(new ReturnStatement(binOp)); yield return(astProvider.OutputNode(this.Options.Dom, methodDeclaration, indent)); methodDeclaration = new MethodDeclaration(); methodDeclaration.Name = "GetHashCode"; methodDeclaration.ReturnType = DomReturnType.Int32.ConvertToTypeReference(); methodDeclaration.Modifiers = ICSharpCode.NRefactory.CSharp.Modifiers.Public | ICSharpCode.NRefactory.CSharp.Modifiers.Override; methodDeclaration.Body = new BlockStatement(); binOp = null; foreach (IMember member in includedMembers) { Expression right; right = new InvocationExpression(new MemberReferenceExpression(new IdentifierExpression(member.Name), "GetHashCode")); IType type = Options.Dom.SearchType(Options.Document.ParsedDocument.CompilationUnit, member is IType ? ((IType)member) : member.DeclaringType, member.Location, member.ReturnType); if (type != null && type.ClassType != MonoDevelop.Projects.Dom.ClassType.Struct && type.ClassType != MonoDevelop.Projects.Dom.ClassType.Enum) { right = new ParenthesizedExpression(new ConditionalExpression(new BinaryOperatorExpression(new IdentifierExpression(member.Name), BinaryOperatorType.InEquality, new PrimitiveExpression(null)), right, new PrimitiveExpression(0))); } if (binOp == null) { binOp = right; } else { binOp = new BinaryOperatorExpression(binOp, BinaryOperatorType.ExclusiveOr, right); } } BlockStatement uncheckedBlock = new BlockStatement(); uncheckedBlock.Statements.Add(new ReturnStatement(binOp)); methodDeclaration.Body.Statements.Add(new UncheckedStatement(uncheckedBlock)); yield return(astProvider.OutputNode(this.Options.Dom, methodDeclaration, indent)); }
void AddTypeArguments (ATypeNameExpression texpr, DomReturnType result) { if (!texpr.HasTypeArguments) return; foreach (var arg in texpr.TypeArguments.Args) { result.AddTypeParameter (ConvertReturnType (arg)); } }
internal IReturnType GetSharedReturnType (DomReturnType rt) { return DomReturnType.GetSharedReturnType (rt); }
public IType GetArrayType (IReturnType elementType, MonoDevelop.Projects.Dom.Output.Ambience ambience) { // Create a fake class which sublcasses System.Array and implements IList<T> DomType t = new DomType (ambience.GetString (elementType, MonoDevelop.Projects.Dom.Output.OutputFlags.UseFullName) + "[]"); // set the compilation unit of the array type to that of the element type - it's required for jumping to the declaration of the type. IType eType = GetType (elementType); if (eType != null) t.CompilationUnit = eType.CompilationUnit; t.Resolved = true; t.BaseType = new DomReturnType ("System.Array"); t.ClassType = ClassType.Class; t.Modifiers = Modifiers.Public; t.SourceProjectDom = this; DomProperty indexer = new DomProperty (); indexer.Name = "Item"; indexer.SetterModifier = indexer.GetterModifier = Modifiers.Public; indexer.PropertyModifier |= PropertyModifier.IsIndexer; indexer.Add (new DomParameter(indexer, "index", DomReturnType.Int32)); indexer.ReturnType = elementType; t.Add (indexer); DomReturnType listType = new DomReturnType ("System.Collections.Generic.IList", false, new IReturnType [] { elementType }); t.AddInterfaceImplementation (listType); return t; }
public override object VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression, object data) { if (memberReferenceExpression == null) { return null; } ResolveResult result; if (String.IsNullOrEmpty (memberReferenceExpression.MemberName)) { if (memberReferenceExpression.TargetObject is TypeReferenceExpression) { result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference); result.StaticResolve = true; return result; } // if (memberReferenceExpression.TargetObject is ThisReferenceExpression) { // result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference); // result.StaticResolve = true; // return result; // } // return memberReferenceExpression.TargetObject.AcceptVisitor(this, data); } result = memberReferenceExpression.TargetObject.AcceptVisitor (this, data) as ResolveResult; NamespaceResolveResult namespaceResult = result as NamespaceResolveResult; if (namespaceResult != null) { if (String.IsNullOrEmpty (memberReferenceExpression.MemberName)) return namespaceResult; string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName; if (resolver.Dom.NamespaceExists (fullName, true)) return new NamespaceResolveResult (fullName); DomReturnType searchType = new DomReturnType (fullName); if (memberReferenceExpression.TypeArguments != null) { foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments) { searchType.AddTypeParameter (NRefactoryResolver.ConvertTypeReference (typeRef)); } } IType type = resolver.Dom.GetType (searchType); if (type != null) { result = CreateResult (this.resolver.Unit, new DomReturnType (type)); result.StaticResolve = true; return result; } return null; } if (result != null && result.ResolvedType != null) { foreach (ResolveResult innerResult in result.ResolveResults) { ResolveResult resolvedResult = ResolveMemberReference (innerResult, memberReferenceExpression); if (resolvedResult != null) return resolvedResult; } } else { if (result != null) MonoDevelop.Core.LoggingService.LogWarning ("Couldn't resolve type " + result.ResolvedType); } return null; }
IEnumerable<KeyValuePair<IMember, IReturnType>> YieldImpls (KeyValuePair<IType, IEnumerable<TreeIter>> kvp) { bool is_interface = kvp.Key.ClassType == ClassType.Interface; IReturnType privateImplementationType = new DomReturnType (kvp.Key.FullName); foreach (TreeIter memberIter in kvp.Value) { yield return new KeyValuePair<IMember, IReturnType> ( GetIMember (memberIter), (is_interface && GetExplicit (memberIter)) ? privateImplementationType : null); } }
public override ICompletionDataList HandleCodeCompletion(CodeCompletionContext completionContext, char completionChar, ref int triggerWordLength) { // IDisposable timer = null; try { if (dom == null /*|| Document.CompilationUnit == null*/) return null; if (completionChar != '#' && stateTracker.Engine.IsInsidePreprocessorDirective) return null; // timer = Counters.ResolveTime.BeginTiming (); DomLocation location = new DomLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset - 1); stateTracker.UpdateEngine (); ExpressionResult result; int cursor, newCursorOffset = 0; switch (completionChar) { case ':': case '.': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext); if (result == null || result.Expression == null) return null; int idx = result.Expression.LastIndexOf ('.'); if (idx > 0) result.Expression = result.Expression.Substring (0, idx); NRefactoryResolver resolver = new NRefactoryResolver (dom, Document.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, Editor, Document.FileName); ResolveResult resolveResult = resolver.Resolve (result, location); if (resolver.ResolvedExpression is ICSharpCode.NRefactory.Ast.PrimitiveExpression) { ICSharpCode.NRefactory.Ast.PrimitiveExpression pex = (ICSharpCode.NRefactory.Ast.PrimitiveExpression)resolver.ResolvedExpression; if (!tryToForceCompletion && !(pex.Value is string || pex.Value is char || pex.Value is bool)) return null; } return CreateCompletionData (location, resolveResult, result, resolver); case '#': if (stateTracker.Engine.IsInsidePreprocessorDirective) return GetDirectiveCompletionData (); return null; case '>': cursor = Editor.SelectionStartPosition; if (stateTracker.Engine.IsInsideDocLineComment) { string lineText = Editor.GetLineText (completionContext.TriggerLine); int startIndex = Math.Min (completionContext.TriggerLineOffset - 1, lineText.Length - 1); while (startIndex >= 0 && lineText[startIndex] != '<') { --startIndex; if (lineText[startIndex] == '/') { // already closed. startIndex = -1; break; } } if (startIndex >= 0) { int endIndex = startIndex; while (endIndex <= completionContext.TriggerLineOffset && endIndex < lineText.Length && !Char.IsWhiteSpace (lineText[endIndex])) { endIndex++; } string tag = endIndex - startIndex - 1 > 0 ? lineText.Substring (startIndex + 1, endIndex - startIndex - 2) : null; if (!String.IsNullOrEmpty (tag) && commentTags.IndexOf (tag) >= 0) { Editor.InsertText (cursor, "</" + tag + ">"); Editor.CursorPosition = cursor; return null; } } } return null; /* Disabled because it gives problems when declaring arrays - for example string [] should not pop up code completion. case '[': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext); if (result.ExpressionContext == ExpressionContext.Attribute) return CreateCtrlSpaceCompletionData (completionContext, result); return null;*/ case '<': if (stateTracker.Engine.IsInsideDocLineComment) return GetXmlDocumentationCompletionData (); return null; case '(': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext, -1); if (result == null || result.Expression == null) return null; resolver = new NRefactoryResolver (dom, Document.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, Editor, Document.FileName); resolveResult = resolver.Resolve (result, new DomLocation (completionContext.TriggerLine, completionContext.TriggerLineOffset - 2)); if (resolveResult != null && resolver.ResolvedExpression is ICSharpCode.NRefactory.Ast.TypeOfExpression) { CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector col = new CompletionDataCollector (completionList, Document.CompilationUnit, location); AddPrimitiveTypes (col); foreach (object o in dom.GetNamespaceContents (GetUsedNamespaces (), true, true)) { col.Add (o); } return completionList; } return null; case '/': cursor = Editor.SelectionStartPosition; if (cursor < 2) break; if (stateTracker.Engine.IsInsideDocLineComment) { string lineText = Editor.GetLineText (completionContext.TriggerLine); bool startsDocComment = true; int slashes = 0; for (int i = 0; i < completionContext.TriggerLineOffset && i < lineText.Length; i++) { if (lineText[i] == '/') { slashes++; continue; } if (!Char.IsWhiteSpace (lineText[i])) { startsDocComment = false; break; } } // check if lines above already start a doc comment for (int i = completionContext.TriggerLine - 1; i >= 0; i--) { string text = Editor.GetLineText (i).Trim (); if (text.Length == 0) continue; if (text.StartsWith ("///")) { startsDocComment = false; break; } break; } // check if following lines start a doc comment for (int i = completionContext.TriggerLine + 1; i < Editor.LineCount; i++) { string text = Editor.GetLineText (i); if (text == null) break; text = text.Trim (); if (text.Length == 0) continue; if (text.StartsWith ("///")) { startsDocComment = false; break; } break; } if (!startsDocComment || slashes != 3) break; StringBuilder generatedComment = new StringBuilder (); bool generateStandardComment = true; ParsedDocument currentParsedDocument = Document.UpdateParseDocument (); IType insideClass = NRefactoryResolver.GetTypeAtCursor (currentParsedDocument.CompilationUnit, Document.FileName, location); if (insideClass != null) { string indent = GetLineWhiteSpace (lineText); if (insideClass.ClassType == ClassType.Delegate) { AppendSummary (generatedComment, indent, out newCursorOffset); IMethod m = null; foreach (IMethod method in insideClass.Methods) m = method; AppendMethodComment (generatedComment, indent, m); generateStandardComment = false; } else { if (!IsInsideClassBody (insideClass, completionContext.TriggerLine, completionContext.TriggerLineOffset)) break; string body = GenerateBody (insideClass, completionContext.TriggerLine, indent, out newCursorOffset); if (!String.IsNullOrEmpty (body)) { generatedComment.Append (body); generateStandardComment = false; } } } if (generateStandardComment) { string indent = GetLineWhiteSpace (Editor.GetLineText (completionContext.TriggerLine)); AppendSummary (generatedComment, indent, out newCursorOffset); } Editor.EndAtomicUndo (); Editor.BeginAtomicUndo (); Editor.InsertText (cursor, generatedComment.ToString ()); Editor.CursorPosition = cursor + newCursorOffset; return null; } return null; case ' ': if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext); if (result == null) return null; int tokenIndex = completionContext.TriggerOffset; string token = GetPreviousToken (ref tokenIndex, false); if (token == "=") { int j = tokenIndex; string prevToken = GetPreviousToken (ref j, false); if (prevToken == "=" || prevToken == "+" || prevToken == "-") { token = prevToken + token; tokenIndex = j; } } switch (token) { case "=": case "==": result = FindExpression (dom, completionContext, tokenIndex - completionContext.TriggerOffset - 1); resolver = new NRefactoryResolver (dom, Document.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, Editor, Document.FileName); resolveResult = resolver.Resolve (result, location); if (resolveResult != null) { IType resolvedType = dom.GetType (resolveResult.ResolvedType); if (resolvedType != null && resolvedType.ClassType == ClassType.Enum) { CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector cdc = new CompletionDataCollector (completionList, Document.CompilationUnit, location); IReturnType returnType = new DomReturnType (resolvedType); bool added = false; foreach (IUsing u in Document.CompilationUnit.Usings) { foreach (KeyValuePair<string, IReturnType> alias in u.Aliases) { if (alias.Value.ToInvariantString () == returnType.ToInvariantString ()) { cdc.Add (alias.Key, "md-class"); added = true; } } } if (!added) cdc.Add (returnType); foreach (object o in CreateCtrlSpaceCompletionData (completionContext, result)) { MemberCompletionData memberData = o as MemberCompletionData; if (memberData == null || memberData.Member == null) continue; if (memberData.Member is IMember) { returnType = ((IMember)memberData.Member).ReturnType; } else if (memberData.Member is IParameter) { returnType = ((IParameter)memberData.Member).ReturnType; } else { returnType = ((LocalVariable)memberData.Member).ReturnType; } if (returnType != null && returnType.FullName == resolvedType.FullName) completionList.Add (memberData); } completionList.AutoCompleteEmptyMatch = false; return completionList; } } return null; case "+=": case "-=": if (stateTracker.Engine.IsInsideDocLineComment || stateTracker.Engine.IsInsideOrdinaryCommentOrString) return null; result = FindExpression (dom, completionContext, tokenIndex - completionContext.TriggerOffset); resolver = new NRefactoryResolver (dom, Document.CompilationUnit, ICSharpCode.NRefactory.SupportedLanguage.CSharp, Editor, Document.FileName); resolveResult = resolver.Resolve (result, location); if (resolveResult is MemberResolveResult) { MemberResolveResult mrr = resolveResult as MemberResolveResult; IEvent evt = mrr.ResolvedMember as IEvent; if (evt == null) return null; IType delegateType = dom.GetType (evt.ReturnType); if (delegateType == null || delegateType.ClassType != ClassType.Delegate) return null; CompletionDataList completionList = new ProjectDomCompletionDataList (); CompletionDataCollector cdc = new CompletionDataCollector (completionList, Document.CompilationUnit, location); IType declaringType = resolver.CallingType; if (Document.LastErrorFreeParsedDocument != null) { declaringType = Document.LastErrorFreeParsedDocument.CompilationUnit.GetType (declaringType.FullName, declaringType.TypeParameters.Count); } IType typeFromDatabase = dom.GetType (declaringType.FullName, new DomReturnType (declaringType).GenericArguments) ?? declaringType; bool includeProtected = DomType.IncludeProtected (dom, typeFromDatabase, resolver.CallingType); foreach (IType type in dom.GetInheritanceTree (typeFromDatabase)) { foreach (IMethod method in type.Methods) { if (method.IsAccessibleFrom (dom, resolver.CallingType, resolver.CallingMember, includeProtected) && MatchDelegate (delegateType, method)) { ICompletionData data = cdc.Add (method); data.SetText (data.CompletionText + ";"); } } } if (token == "+=") { IMethod delegateMethod = delegateType.Methods.First (); completionList.Add ("delegate", "md-keyword", GettextCatalog.GetString ("Creates anonymous delegate."), "delegate {\n" + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + "|\n" + stateTracker.Engine.ThisLineIndent +"};"); StringBuilder sb = new StringBuilder ("("); for (int k = 0; k < delegateMethod.Parameters.Count; k++) { if (k > 0) sb.Append (", "); sb.Append (CompletionDataCollector.ambience.GetString (Document.CompilationUnit.ShortenTypeName (delegateMethod.Parameters[k].ReturnType, Document.TextEditor.CursorLine, Document.TextEditor.CursorColumn), OutputFlags.ClassBrowserEntries | OutputFlags.UseFullName)); sb.Append (" "); sb.Append (delegateMethod.Parameters[k].Name); } sb.Append (")"); completionList.Add ("delegate" + sb, "md-keyword", GettextCatalog.GetString ("Creates anonymous delegate."), "delegate" + sb + " {\n" + stateTracker.Engine.ThisLineIndent + TextEditorProperties.IndentString + "|\n" + stateTracker.Engine.ThisLineIndent +"};"); string varName = GetPreviousToken (ref tokenIndex, false); varName = GetPreviousToken (ref tokenIndex, false); if (varName != ".") { varName = null; } else { List<string> names = new List<string> (); while (varName == ".") { varName = GetPreviousToken (ref tokenIndex, false); if (varName == "this") { names.Add ("handle"); } else if (varName != null) { string trimmedName = varName.Trim (); if (trimmedName.Length == 0) break; names.Insert (0, trimmedName); } varName = GetPreviousToken (ref tokenIndex, false); } varName = String.Join ("", names.ToArray ()); } completionList.Add (new EventCreationCompletionData (((Mono.TextEditor.ITextEditorDataProvider)Document.GetContent<Mono.TextEditor.ITextEditorDataProvider> ()).GetTextEditorData (), varName, delegateType, evt, sb.ToString (), resolver.CallingMember, typeFromDatabase)); } return completionList; } return null; } return HandleKeywordCompletion (completionContext, result, tokenIndex, token); default: if ((Char.IsLetter (completionChar) || completionChar == '_') && TextEditorProperties.EnableAutoCodeCompletion && !stateTracker.Engine.IsInsideDocLineComment && !stateTracker.Engine.IsInsideOrdinaryCommentOrString) { char prevCh = completionContext.TriggerOffset > 2 ? Editor.GetCharAt (completionContext.TriggerOffset - 2) : '\0'; char nextCh = completionContext.TriggerOffset < Editor.TextLength ? Editor.GetCharAt (completionContext.TriggerOffset) : ' '; const string allowedChars = ";[(){}+-*/%^?:&|~!<>="; if (!Char.IsWhiteSpace (nextCh) && allowedChars.IndexOf (nextCh) < 0) return null; if (Char.IsWhiteSpace (prevCh) || allowedChars.IndexOf (prevCh) >= 0) { result = FindExpression (dom, completionContext, -1); if (result == null) return null; if (result.ExpressionContext != ExpressionContext.IdentifierExpected) { triggerWordLength = 1; bool autoSelect = true; int cpos; if ((prevCh == ',' || prevCh == '(') && GetParameterCompletionCommandOffset (out cpos)) { CodeCompletionContext ctx = CompletionWidget.CreateCodeCompletionContext (cpos); NRefactoryParameterDataProvider provider = ParameterCompletionCommand (ctx) as NRefactoryParameterDataProvider; if (provider != null) { int i = provider.GetCurrentParameterIndex (ctx) - 1; if (i < provider.Methods[0].Parameters.Count) { IType returnType = dom.GetType (provider.Methods[0].Parameters[i].ReturnType); autoSelect = returnType == null || returnType.ClassType != ClassType.Delegate; } } } CompletionDataList dataList = CreateCtrlSpaceCompletionData (completionContext, result); dataList.AutoSelect = autoSelect; return dataList; } } } break; } } catch (Exception e) { System.Console.WriteLine("cce: " +e); } finally { // if (timer != null) // timer.Dispose (); } return null; }
public override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) { if (memberReferenceExpression == null) { return(null); } ResolveResult result; if (String.IsNullOrEmpty(memberReferenceExpression.MemberName)) { if (memberReferenceExpression.TargetObject is TypeReferenceExpression) { result = CreateResult(((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference); result.StaticResolve = true; return(result); } // if (memberReferenceExpression.TargetObject is ThisReferenceExpression) { // result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference); // result.StaticResolve = true; // return result; // } // return memberReferenceExpression.TargetObject.AcceptVisitor(this, data); } result = memberReferenceExpression.TargetObject.AcceptVisitor(this, data) as ResolveResult; NamespaceResolveResult namespaceResult = result as NamespaceResolveResult; if (namespaceResult != null) { if (String.IsNullOrEmpty(memberReferenceExpression.MemberName)) { return(namespaceResult); } string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName; if (resolver.Dom.NamespaceExists(fullName, true)) { return(new NamespaceResolveResult(fullName)); } DomReturnType searchType = new DomReturnType(fullName); if (memberReferenceExpression.TypeArguments != null) { foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments) { searchType.AddTypeParameter(NRefactoryResolver.ConvertTypeReference(typeRef)); } } IType type = resolver.Dom.GetType(searchType); if (type != null) { result = CreateResult(this.resolver.Unit, new DomReturnType(type)); result.StaticResolve = true; return(result); } return(null); } if (result != null && result.ResolvedType != null) { foreach (ResolveResult innerResult in result.ResolveResults) { ResolveResult resolvedResult = ResolveMemberReference(innerResult, memberReferenceExpression); if (resolvedResult != null) { return(resolvedResult); } } } else { if (result != null) { MonoDevelop.Core.LoggingService.LogWarning("Couldn't resolve type " + result.ResolvedType); } } return(null); }
static IReturnType ConvertTypeReference (TypeReference typeRef) { if (typeRef == null) return null; DomReturnType result = new DomReturnType (typeRef.Type); foreach (TypeReference genericArgument in typeRef.GenericTypes) { result.AddTypeParameter (ConvertTypeReference (genericArgument)); } result.PointerNestingLevel = typeRef.PointerNestingLevel; if (typeRef.IsArrayType) { result.ArrayDimensions = typeRef.RankSpecifier.Length; for (int i = 0; i < typeRef.RankSpecifier.Length; i++) { result.SetDimension (i, typeRef.RankSpecifier[i]); } } return result; }