static IUnresolvedMethod FunctionToIMethod(ProjectInformation pi, IUnresolvedTypeDefinition type, Function function, string[] contentLines)
{
var method = new DefaultUnresolvedMethod(type, function.Name);
method.Region = new DomRegion((int)function.Line, 1, FindFunctionEnd(contentLines, (int)function.Line - 1) + 2, 1);
Match match;
bool abort = false;
var parameters = new List <IUnresolvedParameter> ();
foreach (string parameter in function.Parameters)
{
match = paramExpression.Match(parameter);
if (null == match)
{
abort = true;
break;
}
var typeRef = new DefaultUnresolvedTypeDefinition(string.Format("{0}{1}{2}", match.Groups["type"].Value, match.Groups["subtype"].Value, match.Groups["array"].Value));
var p = new DefaultUnresolvedParameter(typeRef, match.Groups["name"].Value);
parameters.Add(p);
}
if (!abort)
{
parameters.ForEach(p => method.Parameters.Add(p));
}
return(method);
}
public void ImportOpenGenericType()
{
// class C<T, U> { void M<X>() {} }
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T"));
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U"));
var m = new DefaultUnresolvedMethod(c, "M");
m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "X"));
c.Members.Add(m);
var resolvedC1 = TypeSystemHelper.CreateCompilationAndResolve(c);
var resolvedM1 = resolvedC1.Methods.Single(method => method.Name == "M");
var resolvedC2 = TypeSystemHelper.CreateCompilationAndResolve(c);
var resolvedM2 = resolvedC2.Methods.Single(method => method.Name == "M");
// the types, methods and type parameters differ in the two compilations:
Assert.AreNotEqual(resolvedC1, resolvedC2);
Assert.AreNotEqual(resolvedM1, resolvedM2);
Assert.AreNotEqual(resolvedC1.TypeParameters[1], resolvedC2.TypeParameters[1]);
Assert.AreNotEqual(resolvedM1.TypeParameters[0], resolvedM2.TypeParameters[0]);
// C<U, X>
var pt1 = new ParameterizedType(resolvedC1, new[] { resolvedC1.TypeParameters[1], resolvedM1.TypeParameters[0] });
var pt2 = (ParameterizedType)resolvedC2.Compilation.Import(pt1);
// importing resulted in C<U, X> in the new compilation:
Assert.AreEqual(resolvedC2, pt2.GetDefinition());
Assert.AreEqual(resolvedC2.TypeParameters[1], pt2.TypeArguments[0]);
Assert.AreEqual(resolvedM2.TypeParameters[0], pt2.TypeArguments[1]);
}
public void GetGenericNestedTypeOfBoundGenericClass()
{
// class A<X> { class B<Y> { } }
DefaultUnresolvedTypeDefinition a = new DefaultUnresolvedTypeDefinition(string.Empty, "A");
a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
DefaultUnresolvedTypeDefinition b = new DefaultUnresolvedTypeDefinition(a, "B");
b.TypeParameters.Add(a.TypeParameters[0]);
b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "Y"));
a.NestedTypes.Add(b);
var compilation = TypeSystemHelper.CreateCompilation(a, b);
ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a.FullTypeName);
ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b.FullTypeName);
// A<> gets self-parameterized, B<> stays unbound
Assert.AreEqual("A`1+B`1[[`0],[]]", resolvedA.GetNestedTypes().Single().ReflectionName);
ParameterizedType pt = new ParameterizedType(resolvedA, new [] { compilation.FindType(KnownTypeCode.String) });
Assert.AreEqual("A`1+B`1[[System.String],[]]", pt.GetNestedTypes().Single().ReflectionName);
}
//TODO: handle generics
public static IUnresolvedMethod CodeDomToMDDomMethod(CodeMemberMethod method)
{
var meth = new DefaultUnresolvedMethod(null, method.Name);
meth.ReturnType = new DefaultUnresolvedTypeDefinition(method.ReturnType.BaseType);
CodeDomModifiersToMDDom(meth, method.Attributes);
foreach (CodeParameterDeclarationExpression dec in method.Parameters)
{
var paramType = new DefaultUnresolvedTypeDefinition(dec.Type.BaseType);
var par = new DefaultUnresolvedParameter(paramType, dec.Name);
if (dec.Direction == FieldDirection.Ref)
{
par.IsRef = true;
}
else if (dec.Direction == FieldDirection.Out)
{
par.IsOut = true;
}
meth.Parameters.Add(par);
}
return(meth);
}
public void MultipleInheritanceTest()
{
DefaultUnresolvedTypeDefinition b1 = new DefaultUnresolvedTypeDefinition(string.Empty, "B1");
b1.Kind = TypeKind.Interface;
b1.Members.Add(new DefaultUnresolvedProperty(b1, "P1"));
DefaultUnresolvedTypeDefinition b2 = new DefaultUnresolvedTypeDefinition(string.Empty, "B2");
b2.Kind = TypeKind.Interface;
b2.Members.Add(new DefaultUnresolvedProperty(b2, "P2"));
DefaultUnresolvedTypeDefinition c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.Kind = TypeKind.Interface;
c.BaseTypes.Add(b1);
c.BaseTypes.Add(b2);
var compilation = TypeSystemHelper.CreateCompilation(b1, b2, c);
ITypeDefinition resolvedC = compilation.MainAssembly.GetTypeDefinition(c.FullTypeName);
Assert.AreEqual(new[] { "P1", "P2" }, resolvedC.GetProperties().Select(p => p.Name).ToArray());
// Test that there's only one copy of ToString():
Assert.AreEqual(1, resolvedC.GetMethods(m => m.Name == "ToString").Count());
}
public void EmptyClassHasToString()
{
DefaultUnresolvedTypeDefinition c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
var resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
Assert.AreEqual("System.Object.ToString", resolvedC.GetMethods(m => m.Name == "ToString").Single().FullName);
}
public void ExpansiveInheritance()
{
var a = new DefaultUnresolvedTypeDefinition(string.Empty, "A");
var b = new DefaultUnresolvedTypeDefinition(string.Empty, "B");
// interface A<in U>
a.Kind = TypeKind.Interface;
a.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "U")
{
Variance = VarianceModifier.Contravariant
});
// interface B<X> : A<A<B<X>>> { }
b.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
b.BaseTypes.Add(new ParameterizedTypeReference(
a, new[] { new ParameterizedTypeReference(
a, new [] { new ParameterizedTypeReference(
b, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) }
) }) }));
ICompilation compilation = new SimpleCompilation(CecilLoaderTests.Mscorlib);
ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a);
ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b);
IType type1 = new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.Double) });
IType type2 = new ParameterizedType(resolvedA, new [] { new ParameterizedType(resolvedB, new[] { compilation.FindType(KnownTypeCode.String) }) });
Assert.IsFalse(conversions.ImplicitConversion(type1, type2));
}
static void ApplyModifiers(DefaultUnresolvedTypeDefinition td, Modifiers modifiers)
{
td.Accessibility = GetAccessibility(modifiers) ?? (td.DeclaringTypeDefinition != null ? Accessibility.Private : Accessibility.Internal);
td.IsAbstract = (modifiers & (Modifiers.Abstract | Modifiers.Static)) != 0;
td.IsSealed = (modifiers & (Modifiers.Sealed | Modifiers.Static)) != 0;
td.IsShadowing = (modifiers & Modifiers.New) != 0;
}
public void ClassDerivingFromItself()
{
// class C : C {}
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.BaseTypes.Add(c);
ITypeDefinition resolvedC = Resolve(c);
Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray());
}
public void ClassDerivingFromParameterizedVersionOfItself()
{
// class C<X> : C<C<X>> {}
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "X"));
c.BaseTypes.Add(new ParameterizedTypeReference(c, new [] { new ParameterizedTypeReference(c, new [] { new TypeParameterReference(EntityType.TypeDefinition, 0) }) }));
ITypeDefinition resolvedC = Resolve(c);
Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray());
}
public void TwoClassesDerivingFromEachOther()
{
// class C1 : C2 {} class C2 : C1 {}
var c1 = new DefaultUnresolvedTypeDefinition(string.Empty, "C1");
var c2 = new DefaultUnresolvedTypeDefinition(string.Empty, "C2");
c1.BaseTypes.Add(c2);
c2.BaseTypes.Add(c1);
ITypeDefinition resolvedC1 = Resolve(c1);
ITypeDefinition resolvedC2 = Resolve(c2);
Assert.AreEqual(new [] { resolvedC2, resolvedC1 }, resolvedC1.GetAllBaseTypes().ToArray());
}
/// <summary>
/// Adds the 'Invoke', 'BeginInvoke', 'EndInvoke' methods, and a constructor, to the <paramref name="delegateType"/>.
/// </summary>
public static void AddDefaultMethodsToDelegate(DefaultUnresolvedTypeDefinition delegateType, ITypeReference returnType, IEnumerable<IUnresolvedParameter> parameters)
{
if (delegateType == null)
throw new ArgumentNullException("delegateType");
if (returnType == null)
throw new ArgumentNullException("returnType");
if (parameters == null)
throw new ArgumentNullException("parameters");
DomRegion region = delegateType.Region;
region = new DomRegion(region.FileName, region.BeginLine, region.BeginColumn); // remove end position
DefaultUnresolvedMethod invoke = new DefaultUnresolvedMethod(delegateType, "Invoke");
invoke.Accessibility = Accessibility.Public;
invoke.IsSynthetic = true;
foreach (var p in parameters)
invoke.Parameters.Add(p);
invoke.ReturnType = returnType;
invoke.Region = region;
delegateType.Members.Add(invoke);
DefaultUnresolvedMethod beginInvoke = new DefaultUnresolvedMethod(delegateType, "BeginInvoke");
beginInvoke.Accessibility = Accessibility.Public;
beginInvoke.IsSynthetic = true;
foreach (var p in parameters)
beginInvoke.Parameters.Add(p);
beginInvoke.Parameters.Add(delegateAsyncCallbackParameter);
beginInvoke.Parameters.Add(delegateObjectParameter);
beginInvoke.ReturnType = delegateResultParameter.Type;
beginInvoke.Region = region;
delegateType.Members.Add(beginInvoke);
DefaultUnresolvedMethod endInvoke = new DefaultUnresolvedMethod(delegateType, "EndInvoke");
endInvoke.Accessibility = Accessibility.Public;
endInvoke.IsSynthetic = true;
endInvoke.Parameters.Add(delegateResultParameter);
endInvoke.ReturnType = invoke.ReturnType;
endInvoke.Region = region;
delegateType.Members.Add(endInvoke);
DefaultUnresolvedMethod ctor = new DefaultUnresolvedMethod(delegateType, ".ctor");
ctor.EntityType = EntityType.Constructor;
ctor.Accessibility = Accessibility.Public;
ctor.IsSynthetic = true;
ctor.Parameters.Add(delegateObjectParameter);
ctor.Parameters.Add(delegateIntPtrMethodParameter);
ctor.ReturnType = delegateType;
ctor.Region = region;
delegateType.Members.Add(ctor);
}
static void AddPlaceholders(Step action, IUnresolvedMethod method)
{
var parameters = new List <IUnresolvedParameter> ();
int index = 0;
foreach (var placeholder in action.Placeholders)
{
var typeRef = new DefaultUnresolvedTypeDefinition(placeholder.Name);
var p = new DefaultUnresolvedParameter(typeRef, "p" + index);
method.Parameters.Add(p);
index++;
}
}
ICodeContext CreateContext(ITextEditor editor)
{
var compilation = SD.ParserService.GetCompilationForFile(editor.FileName);
var project = SD.ProjectService.FindProjectContainingFile(editor.FileName);
var resolveContext = new SimpleTypeResolveContext(compilation.MainAssembly);
var currentTypeDefinition = new DefaultUnresolvedTypeDefinition(project.RootNamespace, Path.GetFileNameWithoutExtension(editor.FileName));
ITypeReference baseTypeReference = new GetClassTypeReference("System.Web.Mvc", "WebViewPage", 1);
baseTypeReference = new ParameterizedTypeReference(baseTypeReference, new[] { FindModelType(editor) });
currentTypeDefinition.BaseTypes.Add(baseTypeReference);
var currentMethod = new DefaultUnresolvedMethod(currentTypeDefinition, "__ContextStub__");
currentMethod.ReturnType = KnownTypeReference.Void;
currentTypeDefinition.Members.Add(currentMethod);
var currentResolvedTypeDef = new DefaultResolvedTypeDefinition(resolveContext, currentTypeDefinition);
var projectContent = compilation.MainAssembly.UnresolvedAssembly as IProjectContent;
var currentFile = new CSharpUnresolvedFile();
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Mvc");
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Mvc.Ajax");
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Mvc.Html");
currentFile.RootUsingScope.AddSimpleUsing("System.Web.Routing");
currentFile.TopLevelTypeDefinitions.Add(currentTypeDefinition);
if (projectContent != null)
{
compilation = projectContent.AddOrUpdateFiles(currentFile).CreateCompilation(SD.ParserService.GetCurrentSolutionSnapshot());
}
var context = new CSharpTypeResolveContext(compilation.MainAssembly,
currentFile.RootUsingScope.Resolve(compilation),
currentResolvedTypeDef,
currentMethod.CreateResolved(resolveContext.WithCurrentTypeDefinition(currentResolvedTypeDef)));
return(new CSharpResolver(context));
}
internal static Task <IUnresolvedAssembly> LoadModuleAsync(Module module, ICorDebugModule corModule)
{
string name = corModule.GetName();
if (corModule.IsDynamic() == 1 || corModule.IsInMemory() == 1)
{
var defaultUnresolvedAssembly = new DefaultUnresolvedAssembly(name);
var defaultUnresolvedTypeDefinition = new DefaultUnresolvedTypeDefinition("UnknownDynamicType");
var defaultUnresolvedMethod = new DefaultUnresolvedMethod(defaultUnresolvedTypeDefinition, "UnknownMethod");
var defaultUnresolvedField = new DefaultUnresolvedField(defaultUnresolvedTypeDefinition, "UnknownField");
defaultUnresolvedTypeDefinition.Members.Add(defaultUnresolvedMethod);
defaultUnresolvedTypeDefinition.Members.Add(defaultUnresolvedField);
defaultUnresolvedAssembly.AddTypeDefinition(defaultUnresolvedTypeDefinition);
weakTable.Add(defaultUnresolvedAssembly, new ModuleMetadataInfo(module, null));
return(Task.FromResult <IUnresolvedAssembly>(defaultUnresolvedAssembly));
}
//return Task.FromResult(LoadModule(module, name));
return(Task.Run(() => LoadModule(module, name)));
}
public void ClassDerivingFromTwoInstanciationsOfIEnumerable()
{
// class C : IEnumerable<int>, IEnumerable<uint> {}
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.BaseTypes.Add(typeof(IEnumerable <int>).ToTypeReference());
c.BaseTypes.Add(typeof(IEnumerable <uint>).ToTypeReference());
ITypeDefinition resolvedC = Resolve(c);
IType[] expected =
{
resolvedC,
compilation.FindType(typeof(IEnumerable <int>)),
compilation.FindType(typeof(IEnumerable <uint>)),
compilation.FindType(typeof(IEnumerable)),
compilation.FindType(typeof(object))
};
Assert.AreEqual(expected,
resolvedC.GetAllBaseTypes().OrderBy(t => t.ReflectionName).ToArray());
}
public void StructImplementingIEquatable()
{
// struct S : IEquatable<S> {}
// don't use a Cecil-loaded struct for this test; we're testing the implicit addition of System.ValueType
var s = new DefaultUnresolvedTypeDefinition(string.Empty, "S");
s.Kind = TypeKind.Struct;
s.BaseTypes.Add(new ParameterizedTypeReference(typeof(IEquatable <>).ToTypeReference(), new[] { s }));
ITypeDefinition resolvedS = Resolve(s);
IType[] expected =
{
resolvedS,
s.BaseTypes[0].Resolve(new SimpleTypeResolveContext(resolvedS)),
compilation.FindType(typeof(object)),
compilation.FindType(typeof(ValueType))
};
Assert.AreEqual(expected,
resolvedS.GetAllBaseTypes().OrderBy(t => t.ReflectionName).ToArray());
}
public void TypeParameterDerivingFromOtherTypeParameterInheritsEffectiveBaseClass()
{
// class C<T, U> where T : List<string> where U : T
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T")
{
Constraints = { typeof(List <string>).ToTypeReference() }
});
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U")
{
Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) }
});
ITypeDefinition resolvedC = new SimpleCompilation(CecilLoaderTests.Mscorlib).MainAssembly.GetTypeDefinition(c);
Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType);
Assert.AreEqual(true, resolvedC.TypeParameters[1].IsReferenceType);
Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[0].EffectiveBaseClass.ReflectionName);
Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[1].EffectiveBaseClass.ReflectionName);
}
public void TypeParameterDerivingFromOtherTypeParameterDoesNotInheritReferenceConstraint()
{
// class C<T, U> where T : class where U : T
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T")
{
HasReferenceTypeConstraint = true
});
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U")
{
Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
});
ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
// At runtime, we might have T=System.ValueType and U=int, so C# can't inherit the 'class' constraint
// from one type parameter to another.
Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType);
Assert.IsNull(resolvedC.TypeParameters[1].IsReferenceType);
}
public void TypeParameterDerivingFromOtherTypeParameterInheritsEffectiveBaseClass()
{
// class C<T, U> where T : List<string> where U : T
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "T")
{
Constraints = { typeof(List <string>).ToTypeReference() }
});
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 1, "U")
{
Constraints = { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }
});
ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType);
Assert.AreEqual(true, resolvedC.TypeParameters[1].IsReferenceType);
Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[0].EffectiveBaseClass.ReflectionName);
Assert.AreEqual("System.Collections.Generic.List`1[[System.String]]", resolvedC.TypeParameters[1].EffectiveBaseClass.ReflectionName);
}
static object AddLanguageItem(ProjectInformation pi, DefaultUnresolvedTypeDefinition klass, LanguageItem li, string[] contentLines)
{
if (li is Class || li is Structure || li is Enumeration)
{
var type = LanguageItemToIType(pi, li, contentLines);
klass.NestedTypes.Add(type);
return(type);
}
if (li is Function)
{
var method = FunctionToIMethod(pi, klass, (Function)li, contentLines);
klass.Members.Add(method);
return(method);
}
var field = LanguageItemToIField(klass, li, contentLines);
klass.Members.Add(field);
return(field);
}
public void TypeParameterDerivingFromOtherTypeParameterDoesNotInheritReferenceConstraint()
{
// class C<T, U> where T : class where U : T
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T")
{
HasReferenceTypeConstraint = true
});
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U")
{
Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) }
});
ITypeDefinition resolvedC = new SimpleCompilation(CecilLoaderTests.Mscorlib).MainAssembly.GetTypeDefinition(c);
// At runtime, we might have T=System.ValueType and U=int, so C# can't inherit the 'class' constraint
// from one type parameter to another.
Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType);
Assert.IsNull(resolvedC.TypeParameters[1].IsReferenceType);
}
public override ParsedDocument Parse(bool storeAst, string fileName, TextReader reader, Project project = null)
{
var doc = new DefaultParsedDocument(fileName);
doc.Flags |= ParsedDocumentFlags.NonSerializable;
ProjectInformation pi = ProjectInformationManager.Instance.Get(project);
string content = reader.ReadToEnd();
string[] contentLines = content.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
var globals = new DefaultUnresolvedTypeDefinition("", GettextCatalog.GetString("(Global Scope)"));
lock (pi) {
// Add containers to type list
foreach (LanguageItem li in pi.Containers())
{
if (null == li.Parent && FilePath.Equals(li.File, fileName))
{
var tmp = AddLanguageItem(pi, globals, li, contentLines) as IUnresolvedTypeDefinition;
if (null != tmp)
{
doc.TopLevelTypeDefinitions.Add(tmp);
}
}
}
// Add global category for unscoped symbols
foreach (LanguageItem li in pi.InstanceMembers())
{
if (null == li.Parent && FilePath.Equals(li.File, fileName))
{
AddLanguageItem(pi, globals, li, contentLines);
}
}
}
doc.TopLevelTypeDefinitions.Add(globals);
return(doc);
}
public void ValueTypeParameterDerivingFromReferenceTypeParameter()
{
// class C<T, U> where T : class where U : struct, T
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T")
{
HasReferenceTypeConstraint = true
});
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U")
{
HasValueTypeConstraint = true,
Constraints = { new TypeParameterReference(EntityType.TypeDefinition, 0) }
});
ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilation(c).MainAssembly.GetTypeDefinition(c);
// At runtime, we might have T=System.ValueType and U=int, so C# can't inherit the 'class' constraint
// from one type parameter to another.
Assert.AreEqual(true, resolvedC.TypeParameters[0].IsReferenceType);
Assert.AreEqual(false, resolvedC.TypeParameters[1].IsReferenceType);
}
/// <summary>
/// Create an IMember from a LanguageItem,
/// using the source document to locate declaration bounds.
/// </summary>
/// <param name="pi">
/// A <see cref="ProjectInformation"/> for the current project.
/// </param>
/// <param name="item">
/// A <see cref="LanguageItem"/>: The item to convert.
/// </param>
/// <param name="contentLines">
/// A <see cref="System.String[]"/>: The document in which item is defined.
/// </param>
static DefaultUnresolvedTypeDefinition LanguageItemToIType(ProjectInformation pi, LanguageItem item, string[] contentLines)
{
var klass = new DefaultUnresolvedTypeDefinition("", item.File);
if (item is Class || item is Structure)
{
klass.Region = new DomRegion((int)item.Line, 1, FindFunctionEnd(contentLines, (int)item.Line - 1) + 2, 1);
klass.Kind = item is Class ? TypeKind.Class : TypeKind.Struct;
foreach (LanguageItem li in pi.AllItems())
{
if (klass.Equals(li.Parent) && FilePath.Equals(li.File, item.File))
{
AddLanguageItem(pi, klass, li, contentLines);
}
}
return(klass);
}
klass.Region = new DomRegion((int)item.Line, 1, (int)item.Line + 1, 1);
klass.Kind = TypeKind.Enum;
return(klass);
}
public override System.Threading.Tasks.Task <ParsedDocument> Parse(ParseOptions options, System.Threading.CancellationToken cancellationToken)
{
var fileName = options.FileName;
var project = options.Project;
var doc = new DefaultParsedDocument(fileName);
doc.Flags |= ParsedDocumentFlags.NonSerializable;
ProjectInformation pi = ProjectInformationManager.Instance.Get(project);
string content = options.Content.Text;
string[] contentLines = content.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
var globals = new DefaultUnresolvedTypeDefinition("", GettextCatalog.GetString("(Global Scope)"));
lock (pi) {
// Add containers to type list
foreach (LanguageItem li in pi.Containers())
{
if (null == li.Parent && FilePath.Equals(li.File, fileName))
{
var tmp = AddLanguageItem(pi, globals, li, contentLines) as IUnresolvedTypeDefinition;
if (null != tmp) /*doc.TopLevelTypeDefinitions.Add (tmp);*/ } {
}
}
// Add global category for unscoped symbols
foreach (LanguageItem li in pi.InstanceMembers())
{
if (null == li.Parent && FilePath.Equals(li.File, fileName))
{
AddLanguageItem(pi, globals, li, contentLines);
}
}
}
//doc.TopLevelTypeDefinitions.Add (globals);
return(System.Threading.Tasks.Task.FromResult((ParsedDocument)doc));
}
public override void VisitDocument(AXmlDocument document)
{
currentDocument = document;
AXmlElement rootElement = currentDocument.Children.OfType <AXmlElement>().FirstOrDefault();
if (rootElement != null)
{
string className = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "Class");
string modifier = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "ClassModifier");
if (className != null)
{
TypeDefinition = new DefaultUnresolvedTypeDefinition(className)
{
Kind = TypeKind.Class,
UnresolvedFile = file,
Accessibility = Accessibility.Public,
Region = new DomRegion(file.FileName, textDocument.GetLocation(rootElement.StartOffset), textDocument.GetLocation(rootElement.EndOffset))
};
TypeDefinition.Members.Add(
new DefaultUnresolvedMethod(TypeDefinition, "InitializeComponent")
{
Accessibility = Accessibility.Public,
ReturnType = KnownTypeReference.Void
});
TypeDefinition.Members.Add(
new DefaultUnresolvedField(TypeDefinition, "_contentLoaded")
{
Accessibility = Accessibility.Private,
ReturnType = KnownTypeReference.Boolean
});
var connectMember =
new DefaultUnresolvedMethod(TypeDefinition, "Connect")
{
Accessibility = Accessibility.Private,
ReturnType = KnownTypeReference.Void
};
connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Int32, "connectionId"));
connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Object, "target"));
TypeDefinition.Members.Add(connectMember);
connectMember.ExplicitInterfaceImplementations.Add(
new DefaultMemberReference(SymbolKind.Method, new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)), "Connect"));
var browsableAttribute = new DefaultUnresolvedAttribute(new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)));
browsableAttribute.PositionalArguments.Add(
new SimpleConstantValue(
new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)), System.ComponentModel.EditorBrowsableState.Never
));
connectMember.Attributes.Add(browsableAttribute);
TypeDefinition.BaseTypes.Add(CreateTypeReference(rootElement.Namespace, rootElement.LocalName));
TypeDefinition.BaseTypes.Add(new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)));
if (modifier != null)
{
TypeDefinition.Accessibility = ParseAccessibility(modifier);
}
}
}
base.VisitDocument(document);
}
public void SkeetEvilOverloadResolution()
{
// http://msmvps.com/blogs/jon_skeet/archive/2010/11/02/evil-code-overload-resolution-workaround.aspx
// static void Foo<T>(T? ignored = default(T?)) where T : struct
var m1 = MakeUnresolvedMethod();
m1.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T")
{
HasValueTypeConstraint = true
});
m1.Parameters.Add(MakeOptionalParameter(
NullableType.Create(new TypeParameterReference(EntityType.Method, 0)),
"ignored"
));
// class ClassConstraint<T> where T : class {}
var classConstraint = new DefaultUnresolvedTypeDefinition(string.Empty, "ClassConstraint");
classConstraint.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T")
{
HasReferenceTypeConstraint = true
});
// static void Foo<T>(ClassConstraint<T> ignored = default(ClassConstraint<T>))
// where T : class
var m2 = MakeUnresolvedMethod();
m2.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T")
{
HasReferenceTypeConstraint = true
});
m2.Parameters.Add(MakeOptionalParameter(
new ParameterizedTypeReference(classConstraint, new[] { new TypeParameterReference(EntityType.Method, 0) }),
"ignored"
));
// static void Foo<T>()
var m3 = MakeUnresolvedMethod();
m3.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.Method, 0, "T"));
var context = new SimpleTypeResolveContext(compilation.MainAssembly);
IMethod resolvedM1 = (IMethod)m1.CreateResolved(context);
IMethod resolvedM2 = (IMethod)m2.CreateResolved(context);
IMethod resolvedM3 = (IMethod)m3.CreateResolved(context);
// Call: Foo<int>();
OverloadResolution o;
o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(int)) });
Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM1));
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM2));
Assert.AreSame(resolvedM1, o.BestCandidate);
// Call: Foo<string>();
o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(string)) });
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM1));
Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM2));
Assert.AreSame(resolvedM2, o.BestCandidate);
// Call: Foo<int?>();
o = new OverloadResolution(compilation, new ResolveResult[0], typeArguments: new[] { compilation.FindType(typeof(int?)) });
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM1));
Assert.AreEqual(OverloadResolutionErrors.ConstructedTypeDoesNotSatisfyConstraint, o.AddCandidate(resolvedM2));
Assert.AreEqual(OverloadResolutionErrors.None, o.AddCandidate(resolvedM3));
Assert.AreSame(resolvedM3, o.BestCandidate);
}
ParsedDocument ITypeSystemParser.Parse(bool storeAst, string fileName, TextReader textReader, Project project = null)
{
var doc = new DefaultParsedDocument(fileName);
DefaultUnresolvedTypeDefinition currentFile = null;
DefaultUnresolvedProperty currentRegion = null;
string eol = Environment.NewLine;
string content = textReader.ReadToEnd();
Match eolMatch = eolExpression.Match(content);
if (eolMatch != null && eolMatch.Success)
{
eol = eolMatch.Groups ["eol"].Value;
}
string[] lines = content.Split(new string[] { eol }, StringSplitOptions.None);
int linenum = 1;
Match lineMatch;
foreach (string line in lines)
{
lineMatch = fileHeaderExpression.Match(line.Trim());
if (lineMatch != null && lineMatch.Success)
{
if (currentFile != null) // Close out previous file region
{
currentFile.BodyRegion = new DomRegion(currentFile.BodyRegion.BeginLine,
currentFile.BodyRegion.BeginColumn,
linenum - 1, int.MaxValue);
}
if (currentRegion != null) // Close out previous chunk region
{
currentRegion.BodyRegion = new DomRegion(currentRegion.BodyRegion.BeginLine,
currentRegion.BodyRegion.BeginColumn,
linenum - 1, int.MaxValue);
}
// Create new file region
currentFile = new DefaultUnresolvedTypeDefinition(string.Empty, string.Empty);
currentFile.Region = currentFile.BodyRegion = new DomRegion(lastToken(lineMatch.Groups ["filepath"].Value), linenum, line.Length + 1, linenum, int.MaxValue);
doc.TopLevelTypeDefinitions.Add(currentFile);
}
else
{
lineMatch = chunkExpression.Match(line);
if (lineMatch != null && lineMatch.Success && currentFile != null)
{
if (currentRegion != null) // Close out previous chunk region
{
currentRegion.BodyRegion = new DomRegion(currentRegion.BodyRegion.BeginLine,
currentRegion.BodyRegion.BeginColumn,
linenum - 1, int.MaxValue);
}
// Create new chunk region
currentRegion = new DefaultUnresolvedProperty(currentFile, lineMatch.Groups ["chunk"].Value);
currentRegion.Region = currentRegion.BodyRegion = new DomRegion(currentFile.Region.FileName, linenum, line.Length + 1, linenum, int.MaxValue);
currentFile.Members.Add(currentRegion);
}
}
++linenum;
}
// Close out trailing regions
if (currentFile != null)
{
currentFile.BodyRegion = new DomRegion(currentFile.BodyRegion.BeginLine,
currentFile.BodyRegion.BeginColumn,
Math.Max(1, linenum - 2), int.MaxValue);
}
if (currentRegion != null)
{
currentRegion.BodyRegion = new DomRegion(currentRegion.BodyRegion.BeginLine,
currentRegion.BodyRegion.BeginColumn,
Math.Max(1, linenum - 2), int.MaxValue);
}
return(doc);
}
static void GenerateCU(XmlParsedDocument doc)
{
if (doc.XDocument == null || doc.XDocument.RootElement == null)
{
doc.Add(new Error(ErrorType.Error, "No root node found.", 1, 1));
return;
}
XAttribute rootClass = doc.XDocument.RootElement.Attributes [new XName("x", "Class")];
if (rootClass == null)
{
doc.Add(new Error(ErrorType.Error, "Root node does not contain an x:Class attribute.", 1, 1));
return;
}
bool isApplication = doc.XDocument.RootElement.Name.Name == "Application";
string rootNamespace, rootType, rootAssembly;
XamlG.ParseXmlns(rootClass.Value, out rootType, out rootNamespace, out rootAssembly);
var cu = new DefaultParsedDocument(doc.FileName);
DomRegion rootRegion = doc.XDocument.RootElement.Region;
if (doc.XDocument.RootElement.IsClosed)
{
rootRegion = new DomRegion(doc.XDocument.RootElement.Region.FileName, doc.XDocument.RootElement.Region.Begin, doc.XDocument.RootElement.ClosingTag.Region.End);
}
var declType = new DefaultUnresolvedTypeDefinition(rootNamespace, rootType)
{
Kind = TypeKind.Class,
Accessibility = Accessibility.Public,
Region = rootRegion
};
cu.TopLevelTypeDefinitions.Add(declType);
var initcomp = new DefaultUnresolvedMethod(declType, "InitializeComponent")
{
ReturnType = KnownTypeReference.Void,
Accessibility = Accessibility.Public
};
declType.Members.Add(initcomp);
var _contentLoaded = new DefaultUnresolvedField(declType, "_contentLoaded")
{
ReturnType = KnownTypeReference.Boolean
};
// was missing in the original code: correct ?
// declType.Fields.Add (_contentLoaded);
if (isApplication)
{
return;
}
// cu.Add (new DomUsing (DomRegion.Empty, "System"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Documents"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Input"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media.Animation"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Shapes"));
// cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls.Primitives"));
// Dictionary<string,string> namespaceMap = new Dictionary<string, string> ();
// namespaceMap["x"] = "http://schemas.microsoft.com/winfx/2006/xaml";
XName nameAtt = new XName("x", "Name");
foreach (XElement el in doc.XDocument.RootElement.AllDescendentElements)
{
XAttribute name = el.Attributes [nameAtt];
if (name != null && name.IsComplete)
{
string type = ResolveType(el);
if (type == null || type.Length == 0)
{
cu.Add(new Error(ErrorType.Error, "Could not find namespace for '" + el.Name.FullName + "'.", el.Region.Begin));
}
else
{
declType.Members.Add(new DefaultUnresolvedField(declType, name.Value)
{
Accessibility = Accessibility.Internal,
Region = el.Region,
ReturnType = new DefaultUnresolvedTypeDefinition(type)
});
}
}
}
}
