public void ChainingToGlobalStaticMethodConstructorFromAnotherStaticMethodConstructorWorks()
{
AssertCorrect(
@"class C {
static int F1() { return 0; }
static int F2() { return 0; }
static int F3() { return 0; }
static int F4() { return 0; }
public void M() {}
public C(int a = 1, int b = 2, int c = 3, int d = 4, int e = 5, int f = 6, int g = 7) {
}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(d: F1(), g: F2(), f: F3(), b: F4()) {
M();
}
}",
@"function() {
var $tmp1 = {sm_C}.F1();
var $tmp2 = {sm_C}.F2();
var $tmp3 = {sm_C}.F3();
var $this = ctor$7(1, {sm_C}.F4(), 3, $tmp1, 5, $tmp3, $tmp2);
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor$" + c.Parameters.Count.ToString(CultureInfo.InvariantCulture), isGlobal: true)
});
}
public void ChainingToAnonymousConstructorFromStaticMethodConstructorWorks()
{
AssertCorrect(
@"class C {
static int F1() { return 0; }
static int F2() { return 0; }
static int F3() { return 0; }
static int F4() { return 0; }
public void M() {}
public C(int a = 1, int b = 2, int c = 3, int d = 4, int e = 5, int f = 6, int g = 7) {
}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(d: F1(), g: F2(), f: F3(), b: F4()) {
M();
}
}",
@"function() {
var $tmp1 = {sm_C}.F1();
var $tmp2 = {sm_C}.F2();
var $tmp3 = {sm_C}.F3();
var $this = new {inst_C}(1, {sm_C}.F4(), 3, $tmp1, 5, $tmp3, $tmp2);
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.StaticMethod("ctor") : ConstructorScriptSemantics.Unnamed()
});
}
public void CanCallStaticMethodConstructorWithReorderedAndDefaultArguments()
{
AssertCorrect(
@"class X {
public X(int a = 1, int b = 2, int c = 3, int d = 4, int e = 5, int f = 6, int g = 7) {}
}
int F1() { return 0; }
int F2() { return 0; }
int F3() { return 0; }
int F4() { return 0; }
public void M() {
int a = 0, b = 0, c = 0;
// BEGIN
var x = new X(d: F1(), g: F2(), f: F3(), b: F4());
// END
}",
@" var $tmp1 = this.$F1();
var $tmp2 = this.$F2();
var $tmp3 = this.$F3();
var $x = {sm_X}.create_X(1, this.$F4(), 3, $tmp1, 5, $tmp3, $tmp2);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("create_" + c.DeclaringType.Name), GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void ChainingToStaticMethodParamArrayConstructorThatExpandsArgumentsInNonExpandedFormWorks()
{
AssertCorrect(
@"class C1 {
static int[] args = new[] { 59, 12, 4 };
public C1(int x, int y, params int[] args) {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C1() : this(4, 8, args) {}
}",
@"function() {
var $this = {sm_C1}.ctor$3.apply(null, [4, 8].concat({sm_C1}.$args));
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor$" + c.Parameters.Count.ToString(CultureInfo.InvariantCulture), expandParams: true)
});
AssertCorrect(
@"class C1 {
public C1(int x, int y, params int[] args) {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C1() : this(4, 8, new[] { 59, 12, 4 }) {}
}",
@"function() {
var $this = {sm_C1}.ctor$3(4, 8, 59, 12, 4);
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor$" + c.Parameters.Count.ToString(CultureInfo.InvariantCulture), expandParams: true)
});
}
public void ChainingToJsonConstructorFromStaticMethodConstructorWorks()
{
AssertCorrect(
@"class C {
static int F1() { return 0; }
static int F2() { return 0; }
static int F3() { return 0; }
static int F4() { return 0; }
public int A, B, C, D, E, F, G;
public void M() {}
public C(int a = 1, int b = 2, int c = 3, int d = 4, int e = 5, int f = 6, int g = 7) {
}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(d: F1(), g: F2(), f: F3(), b: F4()) {
M();
}
}",
@"function() {
var $this = { $D: {sm_C}.F1(), $G: {sm_C}.F2(), $F: {sm_C}.F3(), $B: {sm_C}.F4(), $A: 1, $C: 3, $E: 5 };
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.StaticMethod("X") : ConstructorScriptSemantics.Json(c.Parameters.Select(p => c.DeclaringType.GetFields().Single(x => x.Name.Equals(p.Name, StringComparison.InvariantCultureIgnoreCase))))
});
}
public void ReturningFromAStaticMethodConstructorReturnsTheCreatedObject()
{
AssertCorrect(
@"class C {
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public D() {
if (false) {
System.Func<int, int> a = i => i + 1;
return;
}
this.M();
return;
}
}",
@"function() {
var $this = {};
if (false) {
var $a = function($i) {
return $i + 1;
};
return $this;
}
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor")
});
}
public void DefaultConstructorImplementedAsStaticMethodWorks()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = ctor => ConstructorScriptSemantics.StaticMethod("X")
};
Compile(new[] { "class C { }" }, metadataImporter: metadataImporter);
FindStaticMethod("C.X").Should().NotBeNull();
FindNamedConstructor("C.X").Should().BeNull();
}
public void ConstructorImplementedAsStaticMethodGetsAddedToTheStaticMethodsCollectionAndNotTheConstructors()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = ctor => ConstructorScriptSemantics.StaticMethod("X")
};
Compile(new[] { "class C { public C() {} }" }, metadataImporter: metadataImporter);
FindStaticMethod("C.X").Should().NotBeNull();
FindNamedConstructor("C.X").Should().BeNull();
}
public void InvokingStaticMethodParamArrayConstructorThatExpandsArgumentsInExpandedFormWorks()
{
AssertCorrect(
@"class C1 { public C1(int x, int y, params int[] args) {} }
public void M() {
// BEGIN
var c = new C1(4, 8, 59, 12, 4);
// END
}",
@" var $c = {sm_C1}.X(4, 8, 59, 12, 4);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("X", expandParams: true)
});
}
public void CanCallStaticMethodConstructorWithNoArguments()
{
AssertCorrect(
@"class X {
}
public void M() {
// BEGIN
var c = new X();
// END
}",
@" var $c = {sm_X}.create_X();
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("create_" + c.DeclaringType.Name)
});
}
public void ChainingToStaticMethodParamArrayConstructorThatDoesNotExpandArgumentsInExpandedFormWorks()
{
AssertCorrect(
@"class C1 {
public C1(int x, int y, params int[] args) {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C1() : this(4, 8, 59, 12, 4) {}
}",
@"function() {
var $this = {sm_C1}.ctor$3(4, 8, [59, 12, 4]);
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor$" + c.Parameters.Count.ToString(CultureInfo.InvariantCulture))
});
}
public void CanCallStaticMethodConstructorWithArguments()
{
AssertCorrect(
@"class X {
public X(int x, int y, int z) {}
}
public void M() {
int a = 0, b = 0, c = 0;
// BEGIN
var t = new X(a, b, c);
// END
}",
@" var $t = {sm_X}.create_X($a, $b, $c);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("create_" + c.DeclaringType.Name)
});
}
public void CreatingObjectWithDynamicArgumentGivesAnErrorWhenNamesDifferBetweenApplicableMethods()
{
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 => c.Parameters.Count > 0 ? ConstructorScriptSemantics.Named("C$" + c.Parameters[0].Type.Name) : ConstructorScriptSemantics.Unnamed()
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7531));
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 => c.Parameters.Count > 0 ? ConstructorScriptSemantics.StaticMethod("C$" + c.Parameters[0].Type.Name) : ConstructorScriptSemantics.Unnamed()
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages.Any(m => m.Code == 7531));
}
public void CreatingObjectWithDynamicArgumentWorksWhenAllCandidatesAreStaticMethodsWithTheSameName()
{
AssertCorrect(
@"public class C1 {
public C1(int x) {}
public C1(string x) {}
}
public void M() {
dynamic d = null;
// BEGIN
var c = new C1(d);
// END
}",
@" var $c = {sm_C1}.X($d);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("X", generateCode: false)
});
}
public void SimpleStaticMethodConstructorWithoutBaseCallWorks()
{
AssertCorrect(
@"class C {
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() {
this.M();
}
}",
@"function() {
var $this = {};
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor")
});
}
public void InvokingStaticMethodParamArrayConstructorThatExpandsArgumentsInNonExpandedFormWorks()
{
AssertCorrect(
@"public C(int x, int y, params int[] args) {}
public void M() {
var args = new[] { 59, 12, 4 };
// BEGIN
var c1 = new C(4, 8, args);
var c2 = new C(4, 8, new[] { 59, 12, 4 });
// END
}",
@" var $c1 = {sm_C}.X.apply(null, [4, 8].concat($args));
var $c2 = {sm_C}.X(4, 8, 59, 12, 4);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("X", expandParams: true)
});
AssertCorrect(
@"public C(int x, params int[] args) {}
public void M() {
var args = new[] { 59, 12, 4 };
// BEGIN
var c = new C(4, args);
// END
}",
@" var $c = {sm_C}.X.apply(null, [4].concat($args));
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("X", expandParams: true)
});
AssertCorrect(
@"public C(params int[] args) {}
public void M() {
var args = new[] { 59, 12, 4 };
// BEGIN
var c = new C(args);
// END
}",
@" var $c = {sm_C}.X.apply(null, $args);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("X", expandParams: true)
});
}
public void InvokingStaticMethodBaseConstructorMarkedAsSkipInInitializerCreatesAnEmptyObjectLiteral()
{
AssertCorrect(
@"class B {
}
class D : B {
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public D() : base() {
this.M();
}
}",
@"function() {
var $this = {};
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("construct_" + c.DeclaringType.Name, skipInInitializer: c.DeclaringType.Name == "B")
});
}
public void FieldInitializationWorksForStaticMethodConstructors()
{
AssertCorrect(
@"class C {
int x = 1;
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() {
M();
}
}",
@"function() {
var $this = {};
$this.$x = 1;
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor")
});
}
public void ChainingToConstructorImplementedAsInlineCodeFromStaticMethodConstructorWorks()
{
AssertCorrect(
@"class C {
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(0, ""X"") {
M();
}
public C(int x, string s) {
}
}",
@"function() {
var $this = __Literal_(0)._X__;
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.StaticMethod("M") : ConstructorScriptSemantics.InlineCode("__Literal_({x})._{@s}__")
});
}
public void FieldInitializationWorksForStaticMethodConstructorsWhenCallingBase()
{
AssertCorrect(
@"class B {
}
class D : B {
int x = 1;
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public D() {
this.M();
}
}",
@"function() {
var $this = {sm_B}.ctor();
$Init($this, '$x', 1);
$this.M();
return $this;
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.StaticMethod("ctor")
});
}
public void ChainingToStaticMethodConstructorFromAnotherTypeOfConstructorWorks()
{
AssertCorrect(
@"class C {
public static int P { get; set; }
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(P = 0) {
}
public C(int x) {
}
}",
@"function() {
{sm_C}.set_P(0);
$ShallowCopy({sm_C}.ctor(0), this);
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.StaticMethod("ctor")
});
}
public void InvokingBaseStaticMethodConstructorFromAnotherTypeOfConstructorWorks()
{
AssertCorrect(
@"class B {
public B(int x) {}
}
class D : B {
public static int P { get; set; }
[System.Runtime.CompilerServices.CompilerGenerated]
public D() : base(P = 1) {}
}",
@"function() {
{sm_D}.set_P(1);
$ShallowCopy({sm_B}.ctor(1), this);
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.DeclaringType.Name == "D" ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.StaticMethod("ctor")
});
}
public void InvokingBaseStaticMethodConstructorFromAnotherTypeOfConstructorIsAnError()
{
var rpt = new MockErrorReporter(false);
Compile(new[] {
@"class B {
public B() {}
}
class D : B {
public D() {}
}"
}, errorReporter: rpt, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.DeclaringType.Name == "D" ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.StaticMethod("ctor")
});
Assert.That(rpt.AllMessagesText.Any(msg => msg.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase) && msg.IndexOf("static method", StringComparison.InvariantCultureIgnoreCase) >= 0));
}
public void ChainingToStaticMethodConstructorFromAnotherTypeOfConstructorIsAnError()
{
var rpt = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public C() : this(0) {
}
public C(int x) {
}
}"
}, errorReporter: rpt, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.StaticMethod("ctor")
});
Assert.That(rpt.AllMessagesText.Any(msg => msg.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase) && msg.IndexOf("static method", StringComparison.InvariantCultureIgnoreCase) >= 0));
}
public void ConstructorsCanBeOverloadedWithDifferentImplementations()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = ctor => ctor.Parameters[0].Type.Name == "String" ? ConstructorScriptSemantics.Named("StringCtor") : ConstructorScriptSemantics.StaticMethod("IntCtor")
};
Compile(new[] { "class C { C(int i) {} C(string s) {} }" }, metadataImporter: metadataImporter);
FindClass("C").NamedConstructors.Should().HaveCount(1);
FindClass("C").StaticMethods.Should().HaveCount(1);
FindNamedConstructor("C.StringCtor").Should().NotBeNull();
FindStaticMethod("C.IntCtor").Should().NotBeNull();
}
