public void InvokingConstructorImplementedAsInlineCodeWorks()
{
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 = __CreateX_(1)._(this.$F4())._(3)._($tmp1)._(5)._($tmp3)._($tmp2);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.InlineCode("__CreateX_({a})._({b})._({c})._({d})._({e})._({f})._({g})"), GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void ConstructorImplementedAsInlineCodeDoesNotAppearOnTheType()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = ctor => ConstructorScriptSemantics.InlineCode("X")
};
Compile(new[] { "class C { public C() {} }" }, metadataImporter: metadataImporter);
FindClass("C").UnnamedConstructor.Should().BeNull();
}
public void InvokingConstructorImplementedAsInlineCodeWorksForGenericType()
{
AssertCorrect(
@"class X<T1, T2> {
public X(int a, int b) {}
}
public void M() {
// BEGIN
var x = new X<string, int>(13, 42);
// END
}",
@" var $x = __CreateX_({ga_String})._({ga_Int32})._(13)._(42);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.InlineCode("__CreateX_({T1})._({T2})._({a})._({b})"), GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void InvokingConstructorImplementedAsInlineCodeInNonExpandedFormUsesTheNonExpandedCode()
{
AssertCorrect(
@"public C(params int[] args) {}
public void M() {
int[] a = new[] { 1, 2, 3 };
// BEGIN
var c = new C(a);
// END
}
",
@" var $c = _2($a);
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.InlineCode("_({*args})", nonExpandedFormLiteralCode: "_2({args})")
});
}
public void ChainingToInlineCodeConstructorInNonExpandedFormUsesNonExpandedPattern()
{
AssertCorrect(
@"class C {
public static int[] a = null;
public C(params int[] args) {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(a) {
}
}",
@"function() {
$ShallowCopy(_2({sm_C}.$a), this);
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 1 ? ConstructorScriptSemantics.InlineCode("_({*args})", nonExpandedFormLiteralCode: "_2({args})") : ConstructorScriptSemantics.Unnamed()
});
}
public void InvokingConstructorImplementedAsInlineCodeWithExpandedParamArrayParameterInNonExpandedFormIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {
public C1(params int[] args) {}
public void M() {
var a = new[] { 1, 2, 3 };
var c = new C1(a);
}
}"
}, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.InlineCode("_({*args})")
}, errorReporter: er);
Assert.That(er.AllMessages.Any(msg => msg.Severity == MessageSeverity.Error && msg.FormattedMessage.Contains("constructor") && msg.FormattedMessage.Contains("C1") && msg.FormattedMessage.Contains("params parameter expanded")));
}
public void ChainingToInlineCodeConstructorThatUsesExpandedParameterPlaceholderInNonExpandedFormIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C1 {
public static int[] a = null;
public C1(params int[] args) {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C1() : this(a) {
}
}"
}, metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 1 ? ConstructorScriptSemantics.InlineCode("_({*args})") : ConstructorScriptSemantics.Unnamed()
}, errorReporter: er);
Assert.That(er.AllMessages.Any(msg => msg.Severity == MessageSeverity.Error && msg.FormattedMessage.Contains("constructor") && msg.FormattedMessage.Contains("C1") && msg.FormattedMessage.Contains("params parameter expanded")));
}
public void UsingCollectionInitializerWithInlineCodeConstructorWorks()
{
AssertCorrect(
@"class X : System.Collections.IEnumerable {
public void Add(int a) {}
public IEnumerator GetEnumerator() { return null; }
}
public void M() {
int i = 0, j = 0;
// BEGIN
var x = new X { i, j };
// END
}",
@" var $tmp1 = __X__;
$tmp1.Add($i);
$tmp1.Add($j);
var $x = $tmp1;
", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.InlineCode("__X__")
});
}
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 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 ChainingToConstructorImplementedAsInlineCodeFromUnnamedConstructorIsAnError()
{
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.InlineCode("__Literal_{x}_{s}__")
});
Assert.That(rpt.AllMessagesText.Any(msg => msg.StartsWith("Error", StringComparison.InvariantCultureIgnoreCase) && msg.IndexOf("not supported", StringComparison.InvariantCultureIgnoreCase) >= 0));
}
public void ChainingToConstructorImplementedAsInlineCodeFromUnnamedConstructorWprks()
{
AssertCorrect(
@"class C {
static int P { get; set; }
public void M() {}
[System.Runtime.CompilerServices.CompilerGenerated]
public C() : this(P = 42, ""X"") {
M();
}
public C(int x, string s) {
}
}",
@"function() {
{sm_C}.set_P(42);
$ShallowCopy(_(42)._('X'), this);
this.M();
}", metadataImporter: new MockMetadataImporter {
GetConstructorSemantics = c => c.Parameters.Count == 0 ? ConstructorScriptSemantics.Unnamed() : ConstructorScriptSemantics.InlineCode("_({x})._({s})")
});
}
