public void FixtureSetUp()
{
// use "IncludeInternalMembers" so that Cecil results match C# parser results
CecilLoader loader = new CecilLoader() { IncludeInternalMembers = true };
IUnresolvedAssembly asm = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
compilation = new SimpleCompilation(asm, CecilLoaderTests.Mscorlib);
}
ICompilation CreateCompilation()
{
var solutionSnapshot = new TestableSolutionSnapshot(msbuildProject);
msbuildProject.SetProjectContent(projectContent);
ICompilation compilation = new SimpleCompilation(solutionSnapshot, projectContent, projectContent.AssemblyReferences);
solutionSnapshot.AddCompilation(projectContent, compilation);
return compilation;
}
public void ConstructorsAreReportedAsJsonConstructors() {
var compilation = new SimpleCompilation(new CSharpProjectContent());
var er = new MockErrorReporter(true);
var md = new MetadataImporter(er, compilation, new CompilerOptions());
Assert.That(er.AllMessages, Is.Empty, "Prepare should not generate errors");
var t = CreateType(compilation);
var c = md.GetConstructorSemantics(DefaultResolvedMethod.GetDummyConstructor(compilation, t));
Assert.That(c.Type, Is.EqualTo(ConstructorScriptSemantics.ImplType.Json));
}
public void FixtureSetUp()
{
try {
// use "IncludeInternalMembers" so that Cecil results match C# parser results
IkvmLoader loader = new IkvmLoader() { IncludeInternalMembers = true };
IUnresolvedAssembly asm = loader.LoadAssemblyFile(typeof(TestCase.SimplePublicClass).Assembly.Location);
compilation = new SimpleCompilation(asm, IkvmLoaderTests.Mscorlib);
} catch (Exception e) {
Console.WriteLine(e);
throw;
}
}
public void TransparentIdentiferIsValidJavascriptIdentifierStartingWithDollar() {
var compilation = new SimpleCompilation(new CSharpProjectContent());
var er = new MockErrorReporter(true);
var md = new MetadataImporter(er, compilation, new CompilerOptions());
Assert.That(er.AllMessages, Is.Empty, "Prepare should not generate errors");
var t = CreateType(compilation, new[] { "<>Identifier" });
var c = md.GetPropertySemantics(t.GetProperties().Single());
Assert.That(c.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(c.FieldName, Is.EqualTo("$Identifier"));
}
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 void AnonymousTypePropertyNamesAreNotMinimized() {
var compilation = new SimpleCompilation(new CSharpProjectContent());
var er = new MockErrorReporter(true);
var md = new MetadataImporter(er, compilation, new CompilerOptions());
Assert.That(er.AllMessages, Is.Empty, "Prepare should not generate errors");
var t = CreateType(compilation);
var p1 = md.GetPropertySemantics(t.GetProperties().Single(p => p.Name == "prop1"));
Assert.That(p1.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(p1.FieldName, Is.EqualTo("prop1"));
var p2 = md.GetPropertySemantics(t.GetProperties().Single(p => p.Name == "Prop2"));
Assert.That(p2.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(p2.FieldName, Is.EqualTo("Prop2"));
}
public void PropertiesAreImplementedAsFieldsWithTheSameName() {
var compilation = new SimpleCompilation(new CSharpProjectContent());
var er = new MockErrorReporter(true);
var s = new AttributeStore(compilation, er);
var md = new MetadataImporter(er, compilation, s, new CompilerOptions());
Assert.That(er.AllMessages, Is.Empty, "Prepare should not generate errors");
var t = CreateType(compilation);
var p1 = md.GetPropertySemantics(t.GetProperties().Single(p => p.Name == "prop1"));
Assert.That(p1.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(p1.FieldName, Is.EqualTo("prop1"));
var p2 = md.GetPropertySemantics(t.GetProperties().Single(p => p.Name == "Prop2"));
Assert.That(p2.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(p2.FieldName, Is.EqualTo("Prop2"));
}
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 PropertiesAreImplementedAsFieldsWithTheSameName()
{
var compilation = new SimpleCompilation(new CSharpProjectContent());
var md = new MetadataImporter.ScriptSharpMetadataImporter(false);
var er = new MockErrorReporter(true);
md.Prepare(new ITypeDefinition[0], compilation.MainAssembly, er);
Assert.That(er.AllMessagesText, Is.Empty, "Prepare should not generate errors");
var t = CreateType(compilation);
var p1 = md.GetPropertySemantics(t.GetProperties().Single(p => p.Name == "prop1"));
Assert.That(p1.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(p1.FieldName, Is.EqualTo("prop1"));
var p2 = md.GetPropertySemantics(t.GetProperties().Single(p => p.Name == "Prop2"));
Assert.That(p2.Type, Is.EqualTo(PropertyScriptSemantics.ImplType.Field));
Assert.That(p2.FieldName, Is.EqualTo("Prop2"));
}
public virtual ICompilation CreateCompilation()
{
var solutionSnapshot = new DefaultSolutionSnapshot();
ICompilation compilation = new SimpleCompilation(solutionSnapshot, this, assemblyReferences);
solutionSnapshot.AddCompilation(this, compilation);
return compilation;
}
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));
}
public void FindRedirectedType()
{
var compilationWithSystemCore = new SimpleCompilation(systemCore.Value, mscorlib.Value);
var typeRef = ReflectionHelper.ParseReflectionName("System.Func`2, System.Core");
ITypeDefinition c = typeRef.Resolve(compilationWithSystemCore.TypeResolveContext).GetDefinition();
Assert.IsNotNull(c, "System.Func<,> not found");
Assert.AreEqual("mscorlib", c.ParentAssembly.AssemblyName);
}
static ICompilation GetSystemWebDom (TargetRuntime runtime, TargetFramework targetFramework)
{
string file = runtime.AssemblyContext.GetAssemblyNameForVersion (sysWebAssemblyName, targetFramework);
if (string.IsNullOrEmpty (file))
throw new Exception ("System.Web assembly name not found for framework " + targetFramework.Id);
file = runtime.AssemblyContext.GetAssemblyLocation (file, targetFramework);
if (string.IsNullOrEmpty (file))
throw new Exception ("System.Web assembly file not found for framework " + targetFramework.Id);
var dom = new SimpleCompilation (TypeSystemService.LoadAssemblyContext (runtime, targetFramework, file), new IAssemblyReference[] {
TypeSystemService.LoadAssemblyContext (runtime, targetFramework, typeof (object).Assembly.Location)
});
if (dom == null)
throw new Exception ("System.Web parse database not found for framework " + targetFramework.Id + " file '" + file + "'");
return dom;
}
protected IType Resolve (ITreeNavigator treeBuilder, IUnresolvedTypeDefinition type)
{
var mainAssembly = GetMainAssembly (treeBuilder);
if (mainAssembly != null) {
var simpleCompilation = new SimpleCompilation (mainAssembly);
return type.Resolve (new SimpleTypeResolveContext (simpleCompilation.MainAssembly));
}
// TODO: roslyn port ?
// var project = (Project)treeBuilder.GetParentDataItem (typeof(Project), true);
// var ctx = TypeSystemService.GetCompilation (project);
// return ctx.MainAssembly.GetTypeDefinition (type.Namespace, type.Name, type.TypeParameters.Count);
return null;
}
protected ITypeResolveContext GetContext (ITreeNavigator treeBuilder)
{
var mainAssembly = GetMainAssembly (treeBuilder);
if (mainAssembly != null) {
var simpleCompilation = new SimpleCompilation (mainAssembly);
return new SimpleTypeResolveContext (simpleCompilation.MainAssembly);
}
// TODO: roslyn port ?
// var project = (Project)treeBuilder.GetParentDataItem (typeof(Project), true);
// var compilation = TypeSystemService.GetCompilation (project);
// return new SimpleTypeResolveContext (compilation.MainAssembly);
return null;
}
protected IMember Resolve (ITreeNavigator treeBuilder, IUnresolvedMember member)
{
var mainAssembly = GetMainAssembly (treeBuilder);
if (mainAssembly != null) {
var simpleCompilation = new SimpleCompilation (mainAssembly);
return member.CreateResolved (new SimpleTypeResolveContext (simpleCompilation.MainAssembly));
}
var project = (Project)treeBuilder.GetParentDataItem (typeof(Project), true);
var ctx = TypeSystemService.GetCompilation (project);
return member.CreateResolved (ctx.TypeResolveContext);
}
public void CorlibIDStrings()
{
var list = new SimpleCompilation(CecilLoaderTests.Mscorlib).FindType(typeof(List<>)).GetDefinition();
Assert.AreEqual("T:System.Collections.Generic.List`1",
IdStringProvider.GetIdString(list));
Assert.AreEqual("M:System.Collections.Generic.List`1.Add(`0)",
IdStringProvider.GetIdString(list.Methods.Single(m => m.Name == "Add")));
Assert.AreEqual("M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0})",
IdStringProvider.GetIdString(list.Methods.Single(m => m.Name == "AddRange")));
Assert.AreEqual("M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0})",
IdStringProvider.GetIdString(list.Methods.Single(m => m.Name == "ConvertAll")));
}
