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