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);
}
public void CannotUseNotUsableTypeAsAGenericArgument()
{
var nc = new MockMetadataImporter { GetTypeSemantics = t => t.Name == "C1" ? TypeScriptSemantics.NotUsableFromScript() : TypeScriptSemantics.NormalType(t.Name) };
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {}
class C {
public void F1<T>() {}
public void M() {
F1<C1>();
}
}" }, metadataImporter: nc, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("generic argument") && er.AllMessagesText[0].Contains("C1") && er.AllMessagesText[0].Contains("F1"));
er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {}
interface I1<T> {}
class C {
public void F1<T>() {}
public void M() {
F1<I1<I1<C1>>>();
}
}" }, metadataImporter: nc, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("generic argument") && er.AllMessagesText[0].Contains("C1") && er.AllMessagesText[0].Contains("F1"));
}
public void CannotUseNotUsableTypeInATypeOfExpression()
{
var metadataImporter = new MockMetadataImporter { GetTypeSemantics = t => t.Name == "C1" ? TypeScriptSemantics.NotUsableFromScript() : TypeScriptSemantics.NormalType(t.Name) };
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {}
class C {
public void M() {
var t = typeof(C1);
}
}" }, metadataImporter: metadataImporter, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("typeof") && er.AllMessagesText[0].Contains("C1"));
er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {}
interface I1<T> {}
class C {
public void M() {
var t= typeof(I1<I1<C1>>);
}
}" }, metadataImporter: metadataImporter, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("not usable from script") && er.AllMessagesText[0].Contains("typeof") && er.AllMessagesText[0].Contains("C1"));
}
public void AnErrorIsIssuedIfTheMainMethodIsNotImplementedAsANormalMethod()
{
var type = CreateMockTypeDefinition("MyClass");
var main = new Mock<IMethod>(MockBehavior.Strict);
main.SetupGet(_ => _.DeclaringTypeDefinition).Returns(type);
main.SetupGet(_ => _.Name).Returns("Main");
main.SetupGet(_ => _.FullName).Returns("MyClass.Main");
main.SetupGet(_ => _.Parameters).Returns(EmptyList<IParameter>.Instance);
main.SetupGet(_ => _.Region).Returns(DomRegion.Empty);
var er = new MockErrorReporter();
Process(
new[] {
new JsClass(type, JsClass.ClassTypeEnum.Class, null, null, null) {
StaticMethods = { new JsMethod(main.Object, "$Main", new string[0], JsExpression.FunctionDefinition(new string[0], new JsExpressionStatement(JsExpression.Identifier("X")))) }
}
},
new MockScriptSharpMetadataImporter() { GetMethodSemantics = m => ReferenceEquals(m, main.Object) ? MethodScriptSemantics.InlineCode("X") : MethodScriptSemantics.NormalMethod("$" + m.Name) },
er,
main.Object
);
Assert.That(er.AllMessages, Has.Count.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7801 && (string)m.Args[0] == "MyClass.Main"));
}
public void ChangingTheWarningLevelWorks()
{
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"public class C1 { public void M() { var x = 0l; } }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(er.AllMessages.Select(m => m.Code).ToList(), Is.EquivalentTo(new[] { 219, 78 }));
}, "File.cs", "Test.dll", "Test.js");
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"public class C1 { public void M() { var x = 0l; } }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
WarningLevel = 3,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(er.AllMessages.Select(m => m.Code), Is.EqualTo(new[] { 219 }));
}, "File.cs", "Test.dll", "Test.js");
}
public void CanCompileAsyncTaskGenericMethod()
{
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File1.cs"), @"
using System.Threading.Tasks;
public class C1 {
public async Task<int> M() {
var t = new Task(() => {});
await t;
return 0;
}
}");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File1.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js")
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(File.Exists(Path.GetFullPath("Test.dll")), Is.True, "Assembly should be written");
Assert.That(File.Exists(Path.GetFullPath("Test.js")), Is.True, "Script should be written");
}, "File1.cs", "Test.dll", "Test.js");
}
public void AssigningToFieldImplementedAsConstantIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public int F1;
public void M() {
// BEGIN
F1 = 1;
// END
}
}" }, namingConvention: new MockNamingConventionResolver { GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public int F1;
public void M() {
// BEGIN
F1 += 1;
// END
}
}" }, namingConvention: new MockNamingConventionResolver { GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
}
private void AssertCorrect(string code, string feature)
{
var er = new MockErrorReporter();
Compile(new[] { code }, errorReporter: er, allowUnsupportedConstructs: false);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages[0].Code, Is.EqualTo(7998));
Assert.That(er.AllMessages[0].Args[0], Is.EqualTo(feature));
}
protected string Process(IEnumerable<JsType> types, IScriptSharpMetadataImporter metadataImporter = null)
{
metadataImporter = metadataImporter ?? new MockScriptSharpMetadataImporter();
IProjectContent proj = new CSharpProjectContent();
proj = proj.AddAssemblyReferences(new[] { Common.Mscorlib });
var comp = proj.CreateCompilation();
var er = new MockErrorReporter(true);
var obj = new OOPEmulator.ScriptSharpOOPEmulator(metadataImporter, er);
Assert.That(er.AllMessages, Is.Empty, "Should not have errors");
var rewritten = obj.Rewrite(types, comp);
return string.Join("", rewritten.Select(s => OutputFormatter.Format(s, allowIntermediates: true)));
}
public void ConstructorsAreReportedAsJsonConstructors()
{
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 c = md.GetConstructorSemantics(DefaultResolvedMethod.GetDummyConstructor(compilation, t));
Assert.That(c.Type, Is.EqualTo(ConstructorScriptSemantics.ImplType.Json));
}
public void CannotAccessExpandedParamsParameter()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {
public void M(int i, int j, params int[] myParamArray) {
int x = myParamArray[3];
}
}" }, metadataImporter: new MockMetadataImporter { GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name, expandParams: true) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("myParamArray") && er.AllMessagesText[0].Contains("expand") && er.AllMessagesText[0].Contains("param array"));
}
public void TransparentIdentiferIsValidJavascriptIdentifierStartingWithDollar()
{
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, 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 CannotAccessExpandedParamsParameterInExpressionLambda()
{
var er = new MockErrorReporter();
Compile(new[] {
@"public delegate int F(int x, int y, params int[] args);
public class C {
public void M() {
F f = (a, b, myParamArray) => myParamArray[1];
}
}" }, metadataImporter: new MockMetadataImporter { GetDelegateSemantics = d => new DelegateScriptSemantics(expandParams: true) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("myParamArray") && er.AllMessagesText[0].Contains("expand") && er.AllMessagesText[0].Contains("param array"));
}
public void CannotPerformMethodGroupConversionOnMethodThatExpandsParams()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {
public void F(int x, int y, params int[] args) {}
public void M() {
System.Action<int, int, int[]> a = F;
}
}" }, namingConvention: new MockNamingConventionResolver { GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name, expandParams: m.Name == "F") }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("C1.F") && er.AllMessagesText[0].Contains("expand") && er.AllMessagesText[0].Contains("param array"));
}
public void CanCompileProject()
{
var opts = ReadProject(@"C:\Projects\EngineGit\Project\Search\Search.Client\Search.Client.csproj", @"C:\Projects\EngineGit\Project");
opts.DefineConstants.Add("CLIENT");
try {
var er = new MockErrorReporter();
var d = new CompilerDriver(er);
bool result = d.Compile(opts, false);
Assert.That(result, Is.True);
Assert.That(er.AllMessages, Is.Empty);
}
finally {
try { File.Delete(Path.GetFullPath("output.dll")); } catch {}
try { File.Delete(Path.GetFullPath("output.js")); } catch {}
}
}
public void CanCompileMscorlib()
{
var opts = ReadProject(Path.GetFullPath(@"..\..\..\Runtime\src\Libraries\CoreLib\CoreLib.csproj"));
try {
var er = new MockErrorReporter();
var d = new CompilerDriver(er);
bool result = d.Compile(opts, false);
Assert.That(result, Is.True);
Assert.That(er.AllMessages, Is.Empty);
}
finally {
try { File.Delete(Path.GetFullPath("output.dll")); } catch {}
try { File.Delete(Path.GetFullPath("output.js")); } catch {}
}
}
public void InvokingMethodWithExpandedParamArrayWithCommaBeforeWorks()
{
var er = new MockErrorReporter(false);
AssertCorrect(
@"public void F(string p1, int p2, params string[] p3) {}
public void M() {
// BEGIN
F(""x"", 4);
F(""x"", 4, ""y"");
F(""x"", 4, ""y"", ""z"");
// END
}",
@" [ 'x', 4 ];
[ 'x', 4, 'y' ];
[ 'x', 4, 'y', 'z' ];
", namingConvention: new MockNamingConventionResolver { GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("[ {p1}, {p2}{,p3} ]") : MethodScriptSemantics.NormalMethod(m.Name) });
}
public void InvokingMethodWithExpandedParamArrayInNonExpandedFormIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string p1, int p2, params string[] p3) {}
public void M() {
string[] args = null;
// BEGIN
F(""x"", 1, new[] { ""y"", ""z"" });
// END
}
}" }, metadataImporter: new MockMetadataImporter { GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("{p1}*{p2}({*p3})") : MethodScriptSemantics.NormalMethod(m.Name) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F") && m.Contains("expanded")));
}
public void InvokingMethodThatExpectsLiteralStringWithSomethingElseIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string myParameter) {}
public void M() {
string s = ""X"";
// BEGIN
F(s);
// END
}
}" }, metadataImporter: new MockMetadataImporter { GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("invoke_{@myParameter}") : MethodScriptSemantics.NormalMethod(m.Name) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("myParameter") && m.Contains("literal string")));
}
public void InlineCodeWithSyntaxErrorIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string p1, int p2, params string[] p3) {}
public void M() {
string[] args = null;
// BEGIN
F(""x"", 1, ""y"", ""z"");
// END
}
}" }, metadataImporter: new MockMetadataImporter { GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("{p1}*{p2}+") : MethodScriptSemantics.NormalMethod(m.Name) }, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("syntax error")));
}
public void CanInitializeListWithCollectionInitializer()
{
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("Test.cs"), @"using System.Collections.Generic; public class C1 { public void M() { var l = new List<int> { 1 }; } }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("Test.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js")
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True, "Compilation failed with " + string.Join(Environment.NewLine, er.AllMessagesText));
}, "File1.cs", "Test.dll", "Test.js");
}
//[Test, Ignore("Debugging purposes")]
public void CanCompileProject() {
var opts = ReadProject(Path.GetFullPath(@"..\..\..\Runtime\CoreLib.TestScript\CoreLib.TestScript.csproj"));
opts.References.Clear();
opts.References.Add(new Reference(Common.MscorlibPath));
opts.References.Add(new Reference(Path.GetFullPath(@"../../../Runtime/QUnit/bin/Saltarelle.QUnit.dll")));
opts.AlreadyCompiled = true;
try {
var er = new MockErrorReporter();
var d = new CompilerDriver(er);
bool result = d.Compile(opts, null);
Assert.That(result, Is.True);
Assert.That(er.AllMessages, Is.Empty);
}
finally {
try { File.Delete(Path.GetFullPath("output.dll")); } catch {}
try { File.Delete(Path.GetFullPath("output.js")); } catch {}
}
}
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"));
}
protected void Compile(IEnumerable<string> sources, IMetadataImporter metadataImporter = null, INamer namer = null, IRuntimeLibrary runtimeLibrary = null, IErrorReporter errorReporter = null, Action<IMethod, JsFunctionDefinitionExpression, MethodCompiler> methodCompiled = null, IList<string> defineConstants = null, IEnumerable<IAssemblyReference> references = null) {
var sourceFiles = sources.Select((s, i) => new MockSourceFile("File" + i + ".cs", s)).ToList();
bool defaultErrorHandling = false;
if (errorReporter == null) {
defaultErrorHandling = true;
errorReporter = new MockErrorReporter(true);
}
var compiler = new Saltarelle.Compiler.Compiler.Compiler(metadataImporter ?? new MockMetadataImporter(), namer ?? new MockNamer(), runtimeLibrary ?? new MockRuntimeLibrary(), errorReporter);
if (methodCompiled != null)
compiler.MethodCompiled += methodCompiled;
var c = PreparedCompilation.CreateCompilation("x", sourceFiles, references ?? new[] { Common.Mscorlib }, defineConstants);
CompiledTypes = compiler.Compile(c).AsReadOnly();
if (defaultErrorHandling) {
((MockErrorReporter)errorReporter).AllMessages.Should().BeEmpty("Compile should not generate errors");
}
}
public void CompileErrorsAreReportedAndCauseFilesNotToBeGenerated() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"public class C1 { public void M() { var x = y; } }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js")
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, null);
Assert.That(result, Is.False);
Assert.That(er.AllMessages.Any(m => m.Severity == MessageSeverity.Error && m.Code == 103 && m.Region.FileName == Path.GetFullPath("File.cs") && m.Region.Begin == new TextLocation(1, 45) && m.Format != null && m.Args.Length == 0));
Assert.That(File.Exists(Path.GetFullPath("Test.dll")), Is.False, "Assembly should not be written");
Assert.That(File.Exists(Path.GetFullPath("Test.js")), Is.False, "Script should not be written");
}, "File.cs", "Test.dll", "Test.js");
}
public void CanCompileLinqJSTests()
{
var opts = ReadProject(Path.GetFullPath(@"..\..\..\Runtime\src\Tests\LinqJSTests\LinqJSTests.csproj"));
opts.References.Clear();
opts.References.Add(new Reference(Common.MscorlibPath));
opts.References.Add(new Reference(Path.GetFullPath(@"..\..\..\Runtime\bin\Script.Linq.dll")));
try {
var er = new MockErrorReporter();
var d = new CompilerDriver(er);
bool result = d.Compile(opts, false);
Assert.That(result, Is.True);
Assert.That(er.AllMessages, Is.Empty);
}
finally {
try { File.Delete(Path.GetFullPath("output.dll")); } catch {}
try { File.Delete(Path.GetFullPath("output.js")); } catch {}
}
}
protected void Compile(IEnumerable<string> sources, INamingConventionResolver namingConvention = null, IRuntimeLibrary runtimeLibrary = null, IErrorReporter errorReporter = null, Action<IMethod, JsFunctionDefinitionExpression, MethodCompiler> methodCompiled = null, IList<string> defineConstants = null, bool allowUnsupportedConstructs = true, bool referenceSystemCore = false)
{
var sourceFiles = sources.Select((s, i) => new MockSourceFile("File" + i + ".cs", s)).ToList();
bool defaultErrorHandling = false;
if (errorReporter == null) {
defaultErrorHandling = true;
errorReporter = new MockErrorReporter(true);
}
var compiler = new Saltarelle.Compiler.Compiler.Compiler(namingConvention ?? new MockNamingConventionResolver(), runtimeLibrary ?? new MockRuntimeLibrary(), errorReporter) { AllowUnsupportedConstructs = allowUnsupportedConstructs };
if (methodCompiled != null)
compiler.MethodCompiled += methodCompiled;
var references = referenceSystemCore ? new[] { Common.Mscorlib, Common.Linq } : new[] { Common.Mscorlib };
var c = compiler.CreateCompilation(sourceFiles, references, defineConstants);
CompiledTypes = compiler.Compile(c).AsReadOnly();
if (defaultErrorHandling) {
((MockErrorReporter)errorReporter).AllMessagesText.Should().BeEmpty("Compile should not generate errors");
}
}
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]));
}
public void InlineCodeWithSyntaxErrorIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string p1, int p2, params string[] p3) {}
public void M() {
string[] args = null;
// BEGIN
F(""x"", 1, ""y"", ""z"");
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("{p1}*{p2}+") : MethodScriptSemantics.NormalMethod(m.Name)
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("syntax error")));
}
public void InvokingMethodWithExpandedParamArrayInNonExpandedFormIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string p1, int p2, params string[] p3) {}
public void M() {
string[] args = null;
// BEGIN
F(""x"", 1, new[] { ""y"", ""z"" });
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("{p1}*{p2}({*p3})") : MethodScriptSemantics.NormalMethod(m.Name)
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F") && m.Contains("expanded")));
}
public void AnonymousTypePropertyNamesAreNotMinimized()
{
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 CannotCreateADelegateThatBindsThisToFirstParameterFromOneThatDoesNot()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"delegate void D1(int i, int j);
delegate void D2(int a, int b);
class C {
public void M() {
D1 d1 = null;
D2 d2 = new D2(d1);
}
}"
}, metadataImporter: new MockMetadataImporter {
GetDelegateSemantics = d => new DelegateScriptSemantics(bindThisToFirstParameter: d.Name == "D1")
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(e => e.Contains("D1") && e.Contains("D2") && e.Contains("differ in whether the Javascript 'this'")));
}
public void AssemblyThatCanNotBeLocatedCausesError7997() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"class Class1 { public void M() {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath), new Reference("MyNonexistentAssembly") },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
MinimizeScript = false,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(er.AllMessages, Has.Count.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7997 && (string)m.Args[0] == "MyNonexistentAssembly"));
Assert.That(result, Is.False);
Assert.That(File.Exists(Path.GetFullPath("Test.dll")), Is.False);
}, "File.cs", "Test.dll", "Test.js");
}
public void GeneratingDocumentationFileWorks() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"/** <summary>$$$$$$$$$$$$$$$</summary>*/ class Class1 { public void M() {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
DocumentationFile = Path.GetFullPath("Test.xml"),
MinimizeScript = false,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(File.Exists(Path.GetFullPath("Test.xml")), Is.True);
string doc = File.ReadAllText(Path.GetFullPath("Test.xml"));
Assert.That(doc, Is.StringContaining("$$$$$$$$$$$$$$$"));
}, "File.cs", "Test.dll", "Test.js", "Test.xml");
}
public void ClassThatIsNotUsableFromScriptCannotBeUsedAsGenericArgumentForABaseClassOrImplementedInterface()
{
var metadataImporter = new MockMetadataImporter {
GetTypeSemantics = t => t.Name == "C1" ? TypeScriptSemantics.NotUsableFromScript() : TypeScriptSemantics.NormalType(t.Name)
};
var er = new MockErrorReporter(false);
Compile(new[] { "class C1 {} class B1<T> {} class D1 : B1<C1> {}" }, metadataImporter: metadataImporter, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages[0].FormattedMessage.Contains("not usable from script") && er.AllMessages[0].FormattedMessage.Contains("inheritance list") && er.AllMessages[0].FormattedMessage.Contains("C1") && er.AllMessages[0].FormattedMessage.Contains("D1"));
er = new MockErrorReporter(false);
Compile(new[] { "class C1 {} interface I1<T> {} class D1 : I1<C1> {}" }, metadataImporter: metadataImporter, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages[0].FormattedMessage.Contains("not usable from script") && er.AllMessages[0].FormattedMessage.Contains("inheritance list") && er.AllMessages[0].FormattedMessage.Contains("C1") && er.AllMessages[0].FormattedMessage.Contains("D1"));
er = new MockErrorReporter(false);
Compile(new[] { "class C1 {} interface I1<T> {} class D1 : I1<I1<C1>> {}" }, metadataImporter: metadataImporter, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages[0].FormattedMessage.Contains("not usable from script") && er.AllMessages[0].FormattedMessage.Contains("inheritance list") && er.AllMessages[0].FormattedMessage.Contains("C1") && er.AllMessages[0].FormattedMessage.Contains("D1"));
}
public void SpecificWarningsNotAsErrorsWorks() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"public class C1 { public void M() { var x = 0; } }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
TreatWarningsAsErrors = true,
WarningsNotAsErrors = { 219 }
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(er.AllMessages.Any(m => m.Severity == MessageSeverity.Warning && m.Code == 219 && m.Region.FileName == Path.GetFullPath("File.cs") && m.Region.Begin == new TextLocation(1, 41) && m.Format != null && m.Args.Length == 0));
Assert.That(File.Exists(Path.GetFullPath("Test.dll")), Is.True, "Assembly should be written");
Assert.That(File.Exists(Path.GetFullPath("Test.js")), Is.True, "Script should be written");
}, "File.cs", "Test.dll", "Test.js");
}
public void CannotCreateADelegateThatExpandsParamsFromOneThatDoesNot()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"delegate void D1(int i, int j);
delegate void D2(int a, int b);
class C {
public void M() {
D1 d1 = null;
D2 d2 = new D2(d1);
}
}"
}, metadataImporter: new MockMetadataImporter {
GetDelegateSemantics = d => new DelegateScriptSemantics(expandParams: d.Name == "D1")
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(e => e.FormattedMessage.Contains("D1") && e.FormattedMessage.Contains("D2") && e.FormattedMessage.Contains("differ in whether the param array")));
}
public void InvokingMethodThatExpectsLiteralStringWithSomethingElseIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string myParameter) {}
public void M() {
string s = ""X"";
// BEGIN
F(s);
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("invoke_{@myParameter}") : MethodScriptSemantics.NormalMethod(m.Name)
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.FormattedMessage.Contains("myParameter") && m.FormattedMessage.Contains("literal string")));
}
public void UsingExpandedParamArrayInOtherContextIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void F(string p1, int p2, params string[] p3) {}
public void M() {
string[] args = null;
// BEGIN
F(""x"", 1, ""y"", ""z"");
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.InlineCode("{p1}*{p2} + {*p3}") : MethodScriptSemantics.NormalMethod(m.Name)
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.FormattedMessage.Contains("can only be used")));
}
public void ChainingToConstructorImplementedAsJsonFromUnnamedConstructorIsAnError()
{
var rpt = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(0, ""X"") {
M();
}
public C(int x, string s) {
}
}"
}, errorReporter: rpt, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.Json(new IMember[0])
});
Assert.That(rpt.AllMessagesText.Any(msg => msg.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase) && msg.IndexOf("not supported", StringComparison.InvariantCultureIgnoreCase) >= 0));
}
public void MinimizeScriptWorks() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"class Class1 { public void M(int someVariable) {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
MinimizeScript = false,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(File.ReadAllText(Path.GetFullPath("Test.js")).Contains("Class1"), Is.True);
Assert.That(File.ReadAllText(Path.GetFullPath("Test.js")).Contains("someVariable"), Is.True);
Assert.That(File.ReadAllText(Path.GetFullPath("Test.js")).Contains(" "), Is.True);
}, "File.cs", "Test.dll", "Test.js");
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"class Class1 { public void M(int someVariable) {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
MinimizeScript = true,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(File.ReadAllText(Path.GetFullPath("Test.js")).Contains("Class1"), Is.False);
Assert.That(File.ReadAllText(Path.GetFullPath("Test.js")).Contains("someVariable"), Is.False);
Assert.That(File.ReadAllText(Path.GetFullPath("Test.js")).Contains(" "), Is.False);
}, "File.cs", "Test.dll", "Test.js");
}
public void AssemblyThatCanNotBeLocatedCausesError7997()
{
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"class Class1 { public void M() {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath), new Reference("MyNonexistentAssembly") },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("Test.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
MinimizeScript = false,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(er.AllMessages, Has.Count.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7997 && (string)m.Args[0] == "MyNonexistentAssembly"));
Assert.That(result, Is.False);
Assert.That(File.Exists(Path.GetFullPath("Test.dll")), Is.False);
}, "File.cs", "Test.dll", "Test.js");
}
public void ErrorWritingTheDocumentationFileGivesCS7952() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"class Class1 { public void M() {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("MyOutputFile.dll"),
OutputScriptPath = Path.GetFullPath("MyOutputFile.js"),
DocumentationFile = Path.GetFullPath("MyOutputFile.xml"),
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
bool result;
using (File.Open(Path.GetFullPath("MyOutputFile.xml"), FileMode.Create)) {
result = driver.Compile(options, false);
}
Assert.That(result, Is.False);
Assert.That(er.AllMessages.Any(m => m.Code == 7952 && m.Args.Length == 1));
}, "File.cs", "MyOutputFile.dll", "MyOutputFile.js", "MyOutputFile.xml");
}
public void ForeachOverDynamicIsAnError()
{
var er = new MockErrorReporter();
Compile(new[] { @"
using System;
public class C {
public async void M() {
dynamic x = null;
foreach (var i in x) {
}
}
}
",
@" var $tmp1 = $x.getAwaiter();
await $tmp1:onCompleted;
var $i = $tmp1.getResult();
" }, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Severity == MessageSeverity.Error && m.Code == 7542 && m.FormattedMessage.Contains("dynamic")));
}
public void DynamicInvocationOfBaseConstructorIsAnError()
{
var er = new MockErrorReporter();
Compile(new[] {
@"class B {
public B(int x) {}
public B(string x) {}
}
class D : B {
public void M() {}
private static dynamic x;
[System.Runtime.CompilerServices.CompilerGenerated]
public D() : base(x) {
this.M();
}
}"
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7998 && (string)m.Args[0] == "dynamic invocation of base constructor"));
}
public void InitializingMemberThatIsAlsoInitializedWithParameterToMemberMapIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class X {
public int a2;
public X(int a) {}
}
class C {
public void M() {
// BEGIN
var x = new X(123) { a2 = 789 };
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.Json(c.Parameters.Select(p => c.DeclaringType.GetFields().Single(f => f.Name == p.Name + "2")))
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText[0].Contains("a2") && er.AllMessagesText[0].Contains("initializer") && er.AllMessagesText[0].Contains("constructor call"));
}
public void InvokingIndexerWithDynamicArgumentIsAnErrorWhenMoreThanOneMemberIsApplicable()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class X {
public int this[int a, string b] { get { return 0; } set {} }
public int this[int a, int b] { get { return 0; } set {} }
}
class C {
public void M() {
dynamic d = null;
var x = new X();
// BEGIN
var a = x[123, d];
// END
}
}"
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.StartsWith("Error:") && m.Contains("one argument")));
}
protected void Prepare(string source, bool minimizeNames = true, bool expectErrors = false)
{
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpUnresolvedFile {
FileName = "File.cs"
};
var syntaxTree = parser.Parse(rdr, pf.FileName);
syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.AddOrUpdateFiles(pf);
}
project = project.AddAssemblyReferences(new[] { Files.Mscorlib });
var compilation = project.CreateCompilation();
_errorReporter = new MockErrorReporter(!expectErrors);
Metadata = new MetadataImporter(_errorReporter, compilation, new CompilerOptions {
MinimizeScript = minimizeNames
});
Metadata.Prepare(compilation.GetAllTypeDefinitions());
AllErrors = _errorReporter.AllMessages.ToList().AsReadOnly();
AllErrorTexts = _errorReporter.AllMessages.Select(m => m.FormattedMessage).ToList().AsReadOnly();
if (expectErrors)
{
Assert.That(AllErrorTexts, Is.Not.Empty, "Compile should have generated errors");
}
else
{
Assert.That(AllErrorTexts, Is.Empty, "Compile should not generate errors");
}
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
}
public void AssigningToFieldImplementedAsConstantIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public int F1;
public void M() {
// BEGIN
F1 = 1;
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name)
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public int F1;
public void M() {
// BEGIN
F1 += 1;
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name)
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
}
public void DynamicChainingIsAnError()
{
var er = new MockErrorReporter();
Compile(new[] {
@"class B {
}
class C {
public C(int x) {}
public C(string x) {}
public void M() {}
private static dynamic x;
[System.Runtime.CompilerServices.CompilerGenerated]
public D() : this(x) {
this.M();
}
}"
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7998 && (string)m.Args[0] == "dynamic constructor chaining"));
}
public void CreatingObjectWithDynamicArgumentGivesAnErrorWhenTheApplicableMethodsUseInlineCode()
{
var er = new MockErrorReporter();
Compile(new[] {
@"public class C1 {
public C1(int x) {}
public C1(string x) {}
}
public class C {
public void M() {
dynamic d = null;
// BEGIN
var c = new C1(d);
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.InlineCode("X")
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7531));
}
public void CreatingObjectWithDynamicArgumentGivesAnErrorWhenTheSemanticsDifferBetweenApplicableMethods()
{
var er = new MockErrorReporter();
Compile(new[] {
@"public class C1 {
public C1(int x) {}
public C1(string x) {}
}
public class C {
public void M() {
dynamic d = null;
// BEGIN
var c = new C1(x: d);
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 || c.Parameters[0].Type.Name == "Int32" ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.Named("X")
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7526));
}
public void UsingNamedArgumentWithDynamicConstructorInvocationIsAnError()
{
var er = new MockErrorReporter();
Compile(new[] {
@"public class C1 {
public C1(int x) {}
public C1(string x) {}
}
public class C {
public void M() {
dynamic d = null;
// BEGIN
var c = new C1(x: d);
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.Unnamed(generateCode: false)
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7526));
}
public void TheAssemblyNameIsCorrect() {
UsingFiles(() => {
File.WriteAllText(Path.GetFullPath("File.cs"), @"class Class1 { public void M() {} }");
var options = new CompilerOptions {
References = { new Reference(Common.MscorlibPath) },
SourceFiles = { Path.GetFullPath("File.cs") },
OutputAssemblyPath = Path.GetFullPath("MyOutputAssembly.dll"),
OutputScriptPath = Path.GetFullPath("Test.js"),
DocumentationFile = Path.GetFullPath("Test.xml"),
MinimizeScript = false,
};
var er = new MockErrorReporter();
var driver = new CompilerDriver(er);
var result = driver.Compile(options, false);
Assert.That(result, Is.True);
Assert.That(File.Exists(Path.GetFullPath("Test.xml")), Is.True);
string doc = File.ReadAllText(Path.GetFullPath("Test.xml"));
Assert.That(XDocument.Parse(doc).XPathSelectElement("/doc/assembly/name").Value, Is.EqualTo("MyOutputAssembly"));
var asm = AssemblyDefinition.ReadAssembly(Path.GetFullPath("MyOutputAssembly.dll"));
Assert.That(asm.Name.Name, Is.EqualTo("MyOutputAssembly"));
}, "File.cs", "MyOutputAssembly.dll", "Test.js", "Test.xml");
}
private void Prepare(string source, Action preparer)
{
IProjectContent project = new CSharpProjectContent();
var parser = new CSharpParser();
using (var rdr = new StringReader(source)) {
var pf = new CSharpUnresolvedFile("File.cs");
var syntaxTree = parser.Parse(rdr, pf.FileName);
syntaxTree.AcceptVisitor(new TypeSystemConvertVisitor(pf));
project = project.AddOrUpdateFiles(pf);
}
project = project.AddAssemblyReferences(new[] { Files.Mscorlib });
var compilation = project.CreateCompilation();
AllTypes = compilation.MainAssembly.TopLevelTypeDefinitions.SelectMany(SelfAndNested).ToDictionary(t => t.ReflectionName);
var er = new MockErrorReporter(true);
Metadata = new MetadataImporter(er, compilation, new CompilerOptions());
preparer();
Metadata.Prepare(compilation.GetAllTypeDefinitions());
Assert.That(er.AllMessages, Is.Empty, "Should not generate errrors");
}
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);
}
public void UsingPropertyThatIsNotUsableFromScriptGivesAnError() {
var er = new MockErrorReporter(false);
Compile(new[] { "class Class { int UnusableProperty { get; set; } public void M() { UnusableProperty = 0; } }" }, metadataImporter: new MockMetadataImporter { GetPropertySemantics = p => PropertyScriptSemantics.NotUsableFromScript() }, errorReporter: er);
Assert.That(er.AllMessages.Any(msg => msg.Severity == MessageSeverity.Error && msg.FormattedMessage.Contains("Class.UnusableProperty")));
}
