private MinimalCorlib()
: base("corlib")
{
var types = new DefaultUnresolvedTypeDefinition[KnownTypeReference.KnownTypeCodeCount];
for (int i = 0; i < types.Length; i++) {
var typeRef = KnownTypeReference.Get((KnownTypeCode)i);
if (typeRef != null) {
types[i] = new DefaultUnresolvedTypeDefinition(typeRef.Namespace, typeRef.Name);
for (int j = 0; j < typeRef.TypeParameterCount; j++) {
types[i].TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, j));
}
AddTypeDefinition(types[i]);
}
}
for (int i = 0; i < types.Length; i++) {
var typeRef = KnownTypeReference.Get((KnownTypeCode)i);
if (typeRef != null && typeRef.baseType != KnownTypeCode.None) {
types[i].BaseTypes.Add(types[(int)typeRef.baseType]);
if (typeRef.baseType == KnownTypeCode.ValueType && i != (int)KnownTypeCode.Enum) {
types[i].Kind = TypeKind.Struct;
}
}
}
Freeze();
}
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;
}
private MinimalCorlib() : base("corlib")
{
var types = new DefaultUnresolvedTypeDefinition[KnownTypeReference.KnownTypeCodeCount];
for (int i = 0; i < types.Length; i++)
{
var typeRef = KnownTypeReference.Get((KnownTypeCode)i);
if (typeRef != null)
{
types[i] = new DefaultUnresolvedTypeDefinition(typeRef.Namespace, typeRef.Name);
for (int j = 0; j < typeRef.TypeParameterCount; j++)
{
types[i].TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, j));
}
AddTypeDefinition(types[i]);
}
}
for (int i = 0; i < types.Length; i++)
{
var typeRef = KnownTypeReference.Get((KnownTypeCode)i);
if (typeRef != null && typeRef.baseType != KnownTypeCode.None)
{
types[i].BaseTypes.Add(types[(int)typeRef.baseType]);
if (typeRef.baseType == KnownTypeCode.ValueType && i != (int)KnownTypeCode.Enum)
{
types[i].Kind = TypeKind.Struct;
}
}
}
Freeze();
}
public void ImportOpenGenericType()
{
// class C<T, U> { void M<X>() {} }
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 0, "T"));
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.TypeDefinition, 1, "U"));
var m = new DefaultUnresolvedMethod(c, "M");
m.TypeParameters.Add(new DefaultUnresolvedTypeParameter(EntityType.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 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 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 = 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 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 = 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.AreEqual(false, 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);
}
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);
}
/// <summary>
/// Gets an assembly that contains BVE5's primitive and builtin types.
/// </summary>
/// <returns></returns>
public static IUnresolvedAssembly GetBuiltinAssembly()
{
if(builtin_assembly == null){
var builtin_asm = new DefaultUnresolvedAssembly("BVE5Builtin");
foreach(var primitive_type in GetPrimitiveTypeDefs())
builtin_asm.AddTypeDefinition(primitive_type);
var semantic_info = BVE5ResourceManager.RouteFileSemanticInfos;
foreach(var type_name in semantic_info.Keys){
var cur_type_def = new DefaultUnresolvedTypeDefinition("global", type_name);
InitTypeDefinition(semantic_info[type_name], cur_type_def);
builtin_asm.AddTypeDefinition(cur_type_def);
}
builtin_assembly = builtin_asm;
}
return builtin_assembly;
}
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);
ITypeDefinition resolvedC = compilation.MainAssembly.GetTypeDefinition(c);
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 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);
ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a);
ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b);
// 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);
}
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);
}
static IUnresolvedTypeDefinition[] GetPrimitiveTypeDefs()
{
var types = new DefaultUnresolvedTypeDefinition[]{
new DefaultUnresolvedTypeDefinition("global", "void"),
new DefaultUnresolvedTypeDefinition("global", "int"),
new DefaultUnresolvedTypeDefinition("global", "float"),
new DefaultUnresolvedTypeDefinition("global", "name"),
new DefaultUnresolvedTypeDefinition("global", "filepath"),
new DefaultUnresolvedTypeDefinition("global", "time"),
new DefaultUnresolvedTypeDefinition("global", "enumtilt"),
new DefaultUnresolvedTypeDefinition("global", "enumdirection"),
new DefaultUnresolvedTypeDefinition("global", "enumforward")
};
types[0].Kind = TypeKind.Class;
types[1].Kind = TypeKind.Class;
types[2].Kind = TypeKind.Class;
types[3].Kind = TypeKind.Class;
types[4].Kind = TypeKind.Class;
types[5].Kind = TypeKind.Class;
types[6].Kind = TypeKind.Enum;
types[6].Members.Add(MakeEnumField(types[5], "AlwaysHorizontal", 0));
types[6].Members.Add(MakeEnumField(types[5], "RelatedToGradient", 1));
types[6].Members.Add(MakeEnumField(types[5], "RelatedToCant", 2));
types[6].Members.Add(MakeEnumField(types[5], "RelatedToGradientAndCant", 3));
types[7].Kind = TypeKind.Enum;
types[7].Members.Add(MakeEnumField(types[6], "Left", -1));
types[7].Members.Add(MakeEnumField(types[6], "Right", 1));
types[8].Kind = TypeKind.Enum;
types[8].Members.Add(MakeEnumField(types[7], "For", -1));
types[8].Members.Add(MakeEnumField(types[7], "Against", 1));
return types;
}
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);
}
bool isSynthetic = true; // true if all parts are synthetic
public DefaultResolvedTypeDefinition(ITypeResolveContext parentContext, params IUnresolvedTypeDefinition[] parts)
{
if (parentContext == null || parentContext.CurrentAssembly == null)
{
throw new ArgumentException("Parent context does not specify any assembly", "parentContext");
}
if (parts == null || parts.Length == 0)
{
throw new ArgumentException("No parts were specified", "parts");
}
this.parentContext = parentContext;
this.parts = parts;
ITypeResolveContext contextForTypeParameters = parts[0].CreateResolveContext(parentContext);
contextForTypeParameters = contextForTypeParameters.WithCurrentTypeDefinition(this);
this.TypeParameters = parts[0].TypeParameters.CreateResolvedTypeParameters(contextForTypeParameters);
List <IUnresolvedAttribute> unresolvedAttributes = new List <IUnresolvedAttribute>();
List <ITypeResolveContext> contextPerAttribute = new List <ITypeResolveContext>();
List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>();
bool addDefaultConstructorIfRequired = false;
foreach (IUnresolvedTypeDefinition part in parts)
{
ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext);
ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this);
foreach (var attr in part.Attributes)
{
unresolvedAttributes.Add(attr);
contextPerAttribute.Add(parentContextForPart);
}
foreach (var member in part.Members)
{
unresolvedMembers.Add(member);
contextPerMember.Add(contextForPart);
}
isAbstract |= part.IsAbstract;
isSealed |= part.IsSealed;
isShadowing |= part.IsShadowing;
isSynthetic &= part.IsSynthetic; // true if all parts are synthetic
DefaultUnresolvedTypeDefinition dutd = part as DefaultUnresolvedTypeDefinition;
if (dutd != null)
{
addDefaultConstructorIfRequired |= dutd.AddDefaultConstructorIfRequired;
}
// internal is the default, so use another part's accessibility until we find a non-internal accessibility
if (accessibility == Accessibility.Internal)
{
accessibility = part.Accessibility;
}
}
if (addDefaultConstructorIfRequired)
{
TypeKind kind = this.Kind;
if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.EntityType == EntityType.Constructor && !m.IsStatic) ||
kind == TypeKind.Enum || kind == TypeKind.Struct)
{
contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this));
unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0]));
}
}
this.Attributes = new ProjectedListWithContextPerElement <ITypeResolveContext, IUnresolvedAttribute, IAttribute>(contextPerAttribute, unresolvedAttributes, (c, a) => a.CreateResolvedAttribute(c));
this.resolvedMembers = new ProjectedListWithContextPerElement <ITypeResolveContext, IUnresolvedMember, IMember>(contextPerMember, unresolvedMembers, (c, m) => m.CreateResolved(c));
}
MemberList GetMemberList()
{
var result = LazyInit.VolatileRead(ref this.memberList);
if (result != null)
{
return(result);
}
List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>();
List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>();
List <PartialMethodInfo> partialMethodInfos = null;
bool addDefaultConstructorIfRequired = false;
foreach (IUnresolvedTypeDefinition part in parts)
{
ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext);
ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this);
foreach (var member in part.Members)
{
IUnresolvedMethod method = member as IUnresolvedMethod;
if (method != null && (method.IsPartialMethodDeclaration || method.IsPartialMethodImplementation))
{
// Merge partial method declaration and implementation
if (partialMethodInfos == null)
{
partialMethodInfos = new List <PartialMethodInfo>();
}
PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart);
PartialMethodInfo existingInfo = null;
foreach (var info in partialMethodInfos)
{
if (newInfo.IsSameSignature(info, Compilation.NameComparer))
{
existingInfo = info;
break;
}
}
if (existingInfo != null)
{
// Add the unresolved method to the PartialMethodInfo:
existingInfo.AddPart(method, contextForPart);
}
else
{
partialMethodInfos.Add(newInfo);
}
}
else
{
unresolvedMembers.Add(member);
contextPerMember.Add(contextForPart);
}
}
DefaultUnresolvedTypeDefinition dutd = part as DefaultUnresolvedTypeDefinition;
if (dutd != null)
{
addDefaultConstructorIfRequired |= dutd.AddDefaultConstructorIfRequired;
}
}
if (addDefaultConstructorIfRequired)
{
TypeKind kind = this.Kind;
if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.EntityType == EntityType.Constructor && !m.IsStatic) ||
kind == TypeKind.Enum || kind == TypeKind.Struct)
{
contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this));
unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0]));
}
}
result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos);
return(LazyInit.GetOrSet(ref this.memberList, result));
}
public void ClassDerivingFromParameterizedVersionOfItself()
{
// class C<X> : C<C<X>> {}
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.TypeDefinition, 0, "X"));
c.BaseTypes.Add(new ParameterizedTypeReference(c, new [] { new ParameterizedTypeReference(c, new [] { new TypeParameterReference(SymbolKind.TypeDefinition, 0) }) }));
compilation = TypeSystemHelper.CreateCompilation(c);
ITypeDefinition resolvedC = Resolve(c);
Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray());
}
public void ClassDerivingFromItself()
{
// class C : C {}
var c = new DefaultUnresolvedTypeDefinition(string.Empty, "C");
c.BaseTypes.Add(c);
ITypeDefinition resolvedC = TypeSystemHelper.CreateCompilationAndResolve(c);
Assert.AreEqual(new [] { resolvedC }, resolvedC.GetAllBaseTypes().ToArray());
}
public override ParsedDocument 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;
}
//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;
}
DefaultUnresolvedTypeDefinition CreateTopLevelTypeDefinition(IKVM.Reflection.Type typeDefinition)
{
var td = new DefaultUnresolvedTypeDefinition(typeDefinition.Namespace ?? "", ReflectionHelper.SplitTypeParameterCountFromReflectionName (typeDefinition.Name));
if (typeDefinition.IsGenericTypeDefinition)
InitTypeParameters(typeDefinition, td.TypeParameters);
return td;
}
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 }));
compilation = TypeSystemHelper.CreateCompilation(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 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 = TypeSystemHelper.CreateCompilation(a, b);
ITypeDefinition resolvedA = compilation.MainAssembly.GetTypeDefinition(a.FullTypeName);
ITypeDefinition resolvedB = compilation.MainAssembly.GetTypeDefinition(b.FullTypeName);
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).IsValid);
}
void InitNestedTypes(IKVM.Reflection.Type typeDefinition, IUnresolvedTypeDefinition declaringTypeDefinition, ICollection<IUnresolvedTypeDefinition> nestedTypes)
{
foreach (var nestedTypeDef in typeDefinition.GetNestedTypes (bindingFlags)) {
if (IncludeInternalMembers
|| nestedTypeDef.IsNestedPublic
|| nestedTypeDef.IsNestedFamily
|| nestedTypeDef.IsNestedFamORAssem)
{
string name = nestedTypeDef.Name;
int pos = name.LastIndexOf('/');
if (pos > 0)
name = name.Substring(pos + 1);
name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(name);
var nestedType = new DefaultUnresolvedTypeDefinition(declaringTypeDefinition, name);
InitTypeParameters(nestedTypeDef, nestedType.TypeParameters);
nestedTypes.Add(nestedType);
InitTypeDefinition(nestedTypeDef, nestedType);
}
}
}
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);
compilation = TypeSystemHelper.CreateCompilation(c1, c2);
ITypeDefinition resolvedC1 = Resolve(c1);
ITypeDefinition resolvedC2 = Resolve(c2);
Assert.AreEqual(new [] { resolvedC2, resolvedC1 }, resolvedC1.GetAllBaseTypes().ToArray());
}
void InitTypeDefinition(IKVM.Reflection.Type typeDefinition, DefaultUnresolvedTypeDefinition td)
{
td.Kind = GetTypeKind(typeDefinition);
InitTypeModifiers(typeDefinition, td);
InitTypeParameterConstraints(typeDefinition, td.TypeParameters);
// nested types can be initialized only after generic parameters were created
InitNestedTypes(typeDefinition, td, td.NestedTypes);
AddAttributes(typeDefinition, td);
td.HasExtensionMethods = HasExtensionAttribute(typeDefinition);
InitBaseTypes(typeDefinition, td.BaseTypes);
td.AddDefaultConstructorIfRequired = (td.Kind == TypeKind.Struct || td.Kind == TypeKind.Enum);
InitMembers(typeDefinition, td, td.Members);
td.ApplyInterningProvider(interningProvider);
td.Freeze();
RegisterCecilObject(td, typeDefinition);
}
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());
compilation = TypeSystemHelper.CreateCompilation(c);
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());
}
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;
}
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++;
}
}
/// <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 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(SymbolKind.Method, 0, "T") { HasValueTypeConstraint = true });
m1.Parameters.Add(MakeOptionalParameter(
NullableType.Create(new TypeParameterReference(SymbolKind.Method, 0)),
"ignored"
));
// class ClassConstraint<T> where T : class {}
var classConstraint = new DefaultUnresolvedTypeDefinition(string.Empty, "ClassConstraint");
classConstraint.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.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(SymbolKind.Method, 0, "T") { HasReferenceTypeConstraint = true });
m2.Parameters.Add(MakeOptionalParameter(
new ParameterizedTypeReference(classConstraint, new[] { new TypeParameterReference(SymbolKind.Method, 0) }),
"ignored"
));
// static void Foo<T>()
var m3 = MakeUnresolvedMethod();
m3.TypeParameters.Add(new DefaultUnresolvedTypeParameter(SymbolKind.Method, 0, "T"));
ICompilation compilation = TypeSystemHelper.CreateCompilation(classConstraint);
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);
}
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;
}
