internal Tuple<string, ICompilation, IMetadataImporter, MockErrorReporter> Compile(string source, bool includeLinq = false, bool expectErrors = false)
{
var sourceFile = new MockSourceFile("file.cs", source);
var md = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new DefaultNamer();
var er = new MockErrorReporter(!expectErrors);
PreparedCompilation compilation = null;
var rtl = new ScriptSharpRuntimeLibrary(md, er, n.GetTypeParameterName, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return new JsTypeReferenceExpression(t.ParentAssembly, md.GetTypeSemantics(t).Name); });
var compiler = new Compiler.Compiler(md, n, rtl, er);
var references = includeLinq ? new[] { Common.Mscorlib, Common.Linq } : new[] { Common.Mscorlib };
compilation = compiler.CreateCompilation(new[] { sourceFile }, references, null);
var compiledTypes = compiler.Compile(compilation);
if (expectErrors) {
Assert.That(er.AllMessages, Is.Not.Empty, "Compile should have generated errors");
return Tuple.Create((string)null, compilation.Compilation, (IMetadataImporter)md, er);
}
er.AllMessagesText.Should().BeEmpty("Compile should not generate errors");
var js = new OOPEmulator.ScriptSharpOOPEmulator(md, rtl, er).Rewrite(compiledTypes, compilation.Compilation);
js = new GlobalNamespaceReferenceImporter().ImportReferences(js);
string script = string.Join("", js.Select(s => OutputFormatter.Format(s, allowIntermediates: false)));
if (Output == OutputType.GeneratedScript)
Console.WriteLine(script);
return Tuple.Create(script, compilation.Compilation, (IMetadataImporter)md, er);
}
internal Tuple <string, ICompilation, IMetadataImporter, MockErrorReporter> Compile(string source, bool includeLinq = false, bool expectErrors = false)
{
var sourceFile = new MockSourceFile("file.cs", source);
var md = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new DefaultNamer();
var er = new MockErrorReporter(!expectErrors);
PreparedCompilation compilation = null;
var rtl = new ScriptSharpRuntimeLibrary(md, er, n.GetTypeParameterName, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return(new JsTypeReferenceExpression(t.ParentAssembly, md.GetTypeSemantics(t).Name)); });
var compiler = new Compiler.Compiler(md, n, rtl, er, allowUserDefinedStructs: false);
var references = includeLinq ? new[] { Common.Mscorlib, Common.Linq } : new[] { Common.Mscorlib };
compilation = compiler.CreateCompilation(new[] { sourceFile }, references, null);
var compiledTypes = compiler.Compile(compilation);
if (expectErrors)
{
Assert.That(er.AllMessages, Is.Not.Empty, "Compile should have generated errors");
return(Tuple.Create((string)null, compilation.Compilation, (IMetadataImporter)md, er));
}
er.AllMessagesText.Should().BeEmpty("Compile should not generate errors");
var js = new OOPEmulator.ScriptSharpOOPEmulator(compilation.Compilation, md, rtl, er).Rewrite(compiledTypes, compilation.Compilation);
js = new GlobalNamespaceReferenceImporter().ImportReferences(js);
string script = string.Join("", js.Select(s => OutputFormatter.Format(s, allowIntermediates: false)));
if (Output == OutputType.GeneratedScript)
{
Console.WriteLine(script);
}
return(Tuple.Create(script, compilation.Compilation, (IMetadataImporter)md, er));
}
public void BaseTypesAreRegisteredBeforeDerivedTypesGeneric()
{
var sourceFile = new MockSourceFile("file.cs", @"
public class B<T> {}
public interface I<T> {}
public class A : B<int>, I<int> {}
");
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new MockNamer();
var er = new MockErrorReporter(true);
var compilation = new Saltarelle.Compiler.Compiler.Compiler(nc, n, new MockRuntimeLibrary(), er, allowUserDefinedStructs: false).CreateCompilation(new[] { sourceFile }, new[] { Common.Mscorlib }, new string[0]);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// A
var $A = function() {
};
////////////////////////////////////////////////////////////////////////////////
// B
var $B = function() {
};
////////////////////////////////////////////////////////////////////////////////
// I
var $I = function() {
};
{Type}.registerClass(global, 'B', $B);
{Type}.registerInterface(global, 'I', $I, []);
{Type}.registerClass(global, 'A', $A, {C}, {I});
",
new JsClass(ReflectionHelper.ParseReflectionName("A").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("C")), new JsExpression[] { new JsTypeReferenceExpression(Common.CreateMockType("I")) }),
new JsClass(ReflectionHelper.ParseReflectionName("B`1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("I`1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Interface, null, null, new JsExpression[0]));
}
public void BaseTypesAreRegisteredBeforeDerivedTypesGeneric()
{
var sourceFile = new MockSourceFile("file.cs", @"
class B<T> {}
interface I<T> {}
class A : B<int>, I<int> {}
");
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new MockNamer();
var er = new MockErrorReporter(true);
var compilation = new Saltarelle.Compiler.Compiler.Compiler(nc, n, new MockRuntimeLibrary(), er, allowUserDefinedStructs: false).CreateCompilation(new[] { sourceFile }, new[] { Common.Mscorlib }, new string[0]);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// A
{A} = function() {
};
////////////////////////////////////////////////////////////////////////////////
// B
{B} = function() {
};
////////////////////////////////////////////////////////////////////////////////
// I
{I} = function() {
};
{B}.registerClass('B');
{I}.registerClass('I');
{A}.registerClass('A', {C}, {I});
",
new JsClass(ReflectionHelper.ParseReflectionName("A").Resolve(compilation.Compilation).GetDefinition(), "A", JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(compilation.Compilation.MainAssembly, "C"), new JsExpression[] { new JsTypeReferenceExpression(compilation.Compilation.MainAssembly, "I") }),
new JsClass(ReflectionHelper.ParseReflectionName("B`1").Resolve(compilation.Compilation).GetDefinition(), "B", JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("I`1").Resolve(compilation.Compilation).GetDefinition(), "I", JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]));
}
protected override void MainSetupInitializeSolution()
{
_MockSolution.InitializeWithInvalidTargetFile();
_fileToAdd =
_MockSolution.RemoveFile(s => s.AllMockSourceFiles.First());
}
protected override void MainSetupInitializeSolution()
{
_MockSolution.InitializeWithInvalidTargetFile();
_fileToAdd =
_MockSolution.RemoveFile(s => s.AllMockSourceFiles.First());
}
public static Tuple <string, MockErrorReporter> Compile(string source, bool expectErrors = false)
{
var sourceFile = new MockSourceFile("file.cs", source);
var er = new MockErrorReporter(!expectErrors);
var n = new Namer();
var references = new[] { Files.Mscorlib };
var compilation = PreparedCompilation.CreateCompilation("x", new[] { sourceFile }, references, null);;
var s = new AttributeStore(compilation.Compilation, er);
var md = new MetadataImporter(er, compilation.Compilation, s, new CompilerOptions());
var rtl = new RuntimeLibrary(md, er, compilation.Compilation, n, s);
var l = new MockLinker();
md.Prepare(compilation.Compilation.GetAllTypeDefinitions());
var compiler = new Compiler(md, n, rtl, er);
var compiledTypes = compiler.Compile(compilation).ToList();
if (expectErrors)
{
Assert.That(er.AllMessages, Is.Not.Empty, "Compile should have generated errors");
return(Tuple.Create((string)null, er));
}
Assert.That(er.AllMessages, Is.Empty, "Compile should not generate errors");
var js = new OOPEmulatorInvoker(new OOPEmulator(compilation.Compilation, md, rtl, n, l, s, er), md, er).Process(compiledTypes, null);
js = new Linker(md, n, s, compilation.Compilation).Process(js);
string script = OutputFormatter.Format(js, allowIntermediates: false);
return(Tuple.Create(script, er));
}
protected override void MainSetupInitializeSolution()
{
_MockSolution.InitializeWithTargetAndMixinInSeparateClass();
//Save source file - it will be added after solution openend
_sourceFileWithTarget =
_MockSolution.RemoveFile(s => s.AllMockSourceFiles.First(f => f.ContainsPMixinAttribute));
}
protected override void MainSetupInitializeSolution()
{
_MockSolution.InitializeWithTargetAndMixinInSeparateClass();
//Save source file - it will be added after solution openend
_sourceFileWithTarget =
_MockSolution.RemoveFile(s => s.AllMockSourceFiles.First(f => f.ContainsPMixinAttribute));
}
public override void MainSetup()
{
base.MainSetup();
this.AssertCodeBehindFileWasNotGenerated();
//Add Normal Class
this.AddMockSourceFile(s => s.Projects[0], MockSourceFile.CreateDefaultFile());
}
protected Tuple <ICompilation, IOOPEmulator, List <JsType> > Compile(string source, IEnumerable <IAssemblyResource> resources = null, IErrorReporter errorReporter = null)
{
errorReporter = errorReporter ?? new MockErrorReporter(true);
var sourceFile = new MockSourceFile("file.cs", source);
var n = new Namer();
var references = new[] { Files.Mscorlib };
var compilation = PreparedCompilation.CreateCompilation("x", new[] { sourceFile }, references, null, resources);
var s = new AttributeStore(compilation.Compilation, errorReporter);
RunAutomaticMetadataAttributeAppliers(s, compilation.Compilation);
s.RunAttributeCode();
var md = new MetadataImporter(errorReporter, compilation.Compilation, s, new CompilerOptions());
var rtl = new RuntimeLibrary(md, errorReporter, compilation.Compilation, n, s);
md.Prepare(compilation.Compilation.GetAllTypeDefinitions());
var compiler = new Compiler(md, n, rtl, errorReporter);
var compiledTypes = compiler.Compile(compilation).ToList();
return(Tuple.Create(compilation.Compilation, (IOOPEmulator) new OOPEmulator(compilation.Compilation, md, rtl, n, new MockLinker(), s, errorReporter), compiledTypes));
}
public void BaseTypesAreRegisteredBeforeDerivedTypes()
{
var sourceFile = new MockSourceFile("file.cs", @"
public class C3 {}
public interface I1 {}
public class C2 : C3 {}
public class C1 : C2, I1 {}
");
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new MockNamer();
var er = new MockErrorReporter(true);
var compilation = new Saltarelle.Compiler.Compiler.Compiler(nc, n, new MockRuntimeLibrary(), er, allowUserDefinedStructs: false).CreateCompilation(new[] { sourceFile }, new[] { Common.Mscorlib }, new string[0]);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// C1
var $C1 = function() {
};
////////////////////////////////////////////////////////////////////////////////
// C2
var $C2 = function() {
};
////////////////////////////////////////////////////////////////////////////////
// C3
var $C3 = function() {
};
////////////////////////////////////////////////////////////////////////////////
// I1
var $I1 = function() {
};
{Type}.registerClass(global, 'C3', $C3);
{Type}.registerInterface(global, 'I1', $I1, []);
{Type}.registerClass(global, 'C2', $C2, {C3});
{Type}.registerClass(global, 'C1', $C1, {C2}, {I1});
",
new JsClass(ReflectionHelper.ParseReflectionName("C1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("C2")), new JsExpression[] { new JsTypeReferenceExpression(Common.CreateMockType("I1")) }),
new JsClass(ReflectionHelper.ParseReflectionName("C2").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("C3")), new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("C3").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("I1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Interface, null, null, new JsExpression[0]));
}
public void BaseTypesAreRegisteredBeforeDerivedTypes()
{
var sourceFile = new MockSourceFile("file.cs", @"
class C3 {}
interface I1 {}
class C2 : C3 {}
class C1 : C2, I1 {}
");
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new MockNamer();
var er = new MockErrorReporter(true);
var compilation = new Saltarelle.Compiler.Compiler.Compiler(nc, n, new MockRuntimeLibrary(), er).CreateCompilation(new[] { sourceFile }, new[] { Common.Mscorlib }, new string[0]);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// C1
{C1} = function() {
};
////////////////////////////////////////////////////////////////////////////////
// C2
{C2} = function() {
};
////////////////////////////////////////////////////////////////////////////////
// C3
{C3} = function() {
};
////////////////////////////////////////////////////////////////////////////////
// I1
{I1} = function() {
};
{C3}.registerClass('C3');
{I1}.registerInterface('I1', []);
{C2}.registerClass('C2', {C3});
{C1}.registerClass('C1', {C2}, {I1});
",
new JsClass(ReflectionHelper.ParseReflectionName("C1").Resolve(compilation.Compilation).GetDefinition(), "C1", JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(compilation.Compilation.MainAssembly, "C2"), new JsExpression[] { new JsTypeReferenceExpression(compilation.Compilation.MainAssembly, "I1") }),
new JsClass(ReflectionHelper.ParseReflectionName("C2").Resolve(compilation.Compilation).GetDefinition(), "C2", JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(compilation.Compilation.MainAssembly, "C3"), new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("C3").Resolve(compilation.Compilation).GetDefinition(), "C3", JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("I1").Resolve(compilation.Compilation).GetDefinition(), "I1", JsClass.ClassTypeEnum.Interface, null, null, new JsExpression[0]));
}
private Tuple<string, ICompilation, INamingConventionResolver> Compile(string source, bool includeLinq = false)
{
var sourceFile = new MockSourceFile("file.cs", source);
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var er = new MockErrorReporter(true);
PreparedCompilation compilation = null;
var rtl = new ScriptSharpRuntimeLibrary(nc, tr => { var t = tr.Resolve(compilation.Compilation).GetDefinition(); return new JsTypeReferenceExpression(t.ParentAssembly, nc.GetTypeSemantics(t).Name); });
var compiler = new Saltarelle.Compiler.Compiler.Compiler(nc, rtl, er);
er.AllMessagesText.Should().BeEmpty("Compile should not generate errors");
var references = includeLinq ? new[] { Common.Mscorlib, Common.Linq } : new[] { Common.Mscorlib };
compilation = compiler.CreateCompilation(new[] { sourceFile }, references, null);
var compiledTypes = compiler.Compile(compilation);
var js = new OOPEmulator.ScriptSharpOOPEmulator(nc, er).Rewrite(compiledTypes, compilation.Compilation);
js = new GlobalNamespaceReferenceImporter().ImportReferences(js);
string script = string.Join("", js.Select(s => OutputFormatter.Format(s, allowIntermediates: false)));
if (Output == OutputType.GeneratedScript)
Console.WriteLine(script);
return Tuple.Create(script, compilation.Compilation, (INamingConventionResolver)nc);
}
protected string Process(string source, string[] typeNames = null, string entryPoint = null, IErrorReporter errorReporter = null)
{
bool assertNoErrors = errorReporter == null;
errorReporter = errorReporter ?? new MockErrorReporter(true);
var sourceFile = new MockSourceFile("file.cs", source);
var n = new Namer();
var references = new[] { Files.Mscorlib };
var compilation = PreparedCompilation.CreateCompilation(new[] { sourceFile }, references, null);;
var md = new MetadataImporter(errorReporter, compilation.Compilation, new CompilerOptions());
var rtl = new RuntimeLibrary(md, errorReporter, compilation.Compilation, n);
md.Prepare(compilation.Compilation.GetAllTypeDefinitions());
var compiler = new Compiler(md, n, rtl, errorReporter);
var compiledTypes = compiler.Compile(compilation).ToList();
var obj = new OOPEmulator(compilation.Compilation, md, rtl, n, errorReporter);
IMethod ep;
if (entryPoint != null)
{
var type = compiledTypes.Single(c => c.CSharpTypeDefinition.FullName == entryPoint.Substring(0, entryPoint.IndexOf('.')));
ep = type.CSharpTypeDefinition.Methods.Single(m => m.FullName == entryPoint);
}
else
{
ep = null;
}
var rewritten = obj.Process(compiledTypes.Where(t => typeNames == null || typeNames.Contains(t.CSharpTypeDefinition.FullName)), ep);
if (assertNoErrors)
{
Assert.That(((MockErrorReporter)errorReporter).AllMessages, Is.Empty, "Should not have errors");
}
return(string.Join("", rewritten.Select(s => OutputFormatter.Format(s, allowIntermediates: true))));
}
public override void MainSetup()
{
base.MainSetup();
_MockSolution.Projects.Add(
new MockProject
{
MockSourceFiles =
{
MockSourceFile.CreateDefaultFile()
}
});
//Simulate Solution Opening event
EventProxy.FireOnSolutionOpening(this, new EventArgs());
//Simulate Item Saved
EventProxy.FireOnProjectItemSaved(this,
new ProjectItemSavedEventArgs
{
ClassFullPath = _MockSolution.Projects[0].MockSourceFiles[0].FileName,
ProjectFullPath = _MockSolution.Projects[0].FileName
});
}
public override void MainSetup()
{
base.MainSetup();
#region Source Files
var newProjectSourceFile = new MockSourceFile
{
FileName = new FilePath(MockSolution.MockSolutionFolder, "NewProjectSourceFile.cs"),
Source =
@"namespace Testing{
public class NewProjectClass{ public void AMethod(){} }
}"
};
_sourceFile.Source =
@" namespace Testing
{
[CopaceticSoftware.pMixins.Attributes.pMixin(Mixin = typeof(NewProjectClass))]
public partial class Target {
}
}";
#endregion
// Set Initial Solution State
_MockSolution.Projects.Add(new MockProject
{
MockSourceFiles = new[] { _sourceFile }
});
this.FireSolutionOpen();
//Code Generator should not be able to generate Mixin code yet
Assert.False(
CanGenerateMixinCodeForSourceFile(_sourceFile),
"Should not be able to generate Mixin code for _sourceFile yet! Was the file built correctly?");
//Simulate adding a new Project
_MockSolution.Projects.Add(
new MockProject
{
FileName = new FilePath(MockSolution.MockSolutionFolder, "NewProject.csproj"),
MockSourceFiles = new[] { newProjectSourceFile }
});
EventProxy.FireOnProjectAdded(this, new ProjectAddedEventArgs
{
ProjectFullPath = _MockSolution.Projects[1].FileName
});
//Simulate adding a reference to the new Project
_MockSolution.Projects[0].ProjectReferences.Add(
_MockSolution.Projects[1]);
EventProxy.FireOnProjectReferenceAdded(this, new ProjectReferenceAddedEventArgs
{
ProjectFullPath = _MockSolution.Projects[0].FileName,
ReferencePath = _MockSolution.Projects[1].FileName
});
//Expect Project File will be reread (by test AssemblyResolver)
_MockFileWrapper.Expect(x => x.ReadAllText(Arg.Is(_MockSolution.Projects[0].FileName)));
}
public void BaseTypesAreRegisteredBeforeDerivedTypesGeneric()
{
var sourceFile = new MockSourceFile("file.cs", @"
public class B<T> {}
public interface I<T> {}
public class A : B<int>, I<int> {}
");
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new MockNamer();
var er = new MockErrorReporter(true);
var compilation = new Saltarelle.Compiler.Compiler.Compiler(nc, n, new MockRuntimeLibrary(), er, allowUserDefinedStructs: false).CreateCompilation(new[] { sourceFile }, new[] { Common.Mscorlib }, new string[0]);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// A
var $A = function() {
};
////////////////////////////////////////////////////////////////////////////////
// B
var $B = function() {
};
////////////////////////////////////////////////////////////////////////////////
// I
var $I = function() {
};
{Type}.registerClass(global, 'B', $B);
{Type}.registerInterface(global, 'I', $I, []);
{Type}.registerClass(global, 'A', $A, {C}, {I});
",
new JsClass(ReflectionHelper.ParseReflectionName("A").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("C")), new JsExpression[] { new JsTypeReferenceExpression(Common.CreateMockType("I")) }),
new JsClass(ReflectionHelper.ParseReflectionName("B`1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("I`1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Interface, null, null, new JsExpression[0]));
}
public override void MainSetup()
{
base.MainSetup();
#region Source Files
var newProjectSourceFile = new MockSourceFile
{
FileName = new FilePath(MockSolution.MockSolutionFolder, "NewProjectSourceFile.cs"),
Source =
@"namespace Testing{
public class NewProjectClass{ public void AMethod(){} }
}"
};
_sourceFile.Source =
@" namespace Testing
{
[CopaceticSoftware.pMixins.Attributes.pMixin(Mixin = typeof(NewProjectClass))]
public partial class Target {
}
}";
#endregion
// Set Initial Solution State
_MockSolution.Projects.Add(new MockProject
{
MockSourceFiles = new[] { _sourceFile }
});
this.FireSolutionOpen();
//Code Generator should not be able to generate Mixin code yet
Assert.False(
CanGenerateMixinCodeForSourceFile(_sourceFile),
"Should not be able to generate Mixin code for _sourceFile yet! Was the file built correctly?");
//Simulate adding a new Project
_MockSolution.Projects.Add(
new MockProject
{
FileName = new FilePath(MockSolution.MockSolutionFolder, "NewProject.csproj"),
MockSourceFiles = new[] { newProjectSourceFile }
});
EventProxy.FireOnProjectAdded(this, new ProjectAddedEventArgs
{
ProjectFullPath = _MockSolution.Projects[1].FileName
});
//Simulate adding a reference to the new Project
_MockSolution.Projects[0].ProjectReferences.Add(
_MockSolution.Projects[1]);
EventProxy.FireOnProjectReferenceAdded(this, new ProjectReferenceAddedEventArgs
{
ProjectFullPath = _MockSolution.Projects[0].FileName,
ReferencePath = _MockSolution.Projects[1].FileName
});
//Expect Project File will be reread (by test AssemblyResolver)
_MockFileWrapper.Expect(x => x.ReadAllText(Arg.Is(_MockSolution.Projects[0].FileName)));
}
public void BaseTypesAreRegisteredBeforeDerivedTypes()
{
var sourceFile = new MockSourceFile("file.cs", @"
public class C3 {}
public interface I1 {}
public class C2 : C3 {}
public class C1 : C2, I1 {}
");
var nc = new MetadataImporter.ScriptSharpMetadataImporter(false);
var n = new MockNamer();
var er = new MockErrorReporter(true);
var compilation = new Saltarelle.Compiler.Compiler.Compiler(nc, n, new MockRuntimeLibrary(), er, allowUserDefinedStructs: false).CreateCompilation(new[] { sourceFile }, new[] { Common.Mscorlib }, new string[0]);
AssertCorrect(
@"////////////////////////////////////////////////////////////////////////////////
// C1
var $C1 = function() {
};
////////////////////////////////////////////////////////////////////////////////
// C2
var $C2 = function() {
};
////////////////////////////////////////////////////////////////////////////////
// C3
var $C3 = function() {
};
////////////////////////////////////////////////////////////////////////////////
// I1
var $I1 = function() {
};
{Type}.registerClass(global, 'C3', $C3);
{Type}.registerInterface(global, 'I1', $I1, []);
{Type}.registerClass(global, 'C2', $C2, {C3});
{Type}.registerClass(global, 'C1', $C1, {C2}, {I1});
",
new JsClass(ReflectionHelper.ParseReflectionName("C1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("C2")), new JsExpression[] { new JsTypeReferenceExpression(Common.CreateMockType("I1")) }),
new JsClass(ReflectionHelper.ParseReflectionName("C2").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, new JsTypeReferenceExpression(Common.CreateMockType("C3")), new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("C3").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Class, null, null, new JsExpression[0]),
new JsClass(ReflectionHelper.ParseReflectionName("I1").Resolve(compilation.Compilation).GetDefinition(), JsClass.ClassTypeEnum.Interface, null, null, new JsExpression[0]));
}
