public void InstanceAutoPropertyAccessorsImplementedAsStaticMethodsAreCorrectlyCompiled()
{
Compile(new[] { "using System; class C { public int MyProperty { get; set; } }" }, metadataImporter: new MockMetadataImporter {
GetPropertySemantics = p => PropertyScriptSemantics.GetAndSetMethods(MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("get_" + p.Name), MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("set_" + p.Name))
});
var getter = FindStaticMethod("C.get_MyProperty");
var setter = FindStaticMethod("C.set_MyProperty");
AssertCorrect(getter.Definition,
@"function($this) {
return $this.$MyProperty;
}");
AssertCorrect(setter.Definition,
@"function($this, $value) {
$this.$MyProperty = $value;
}");
AssertCorrect(FindClass("C").UnnamedConstructor,
@"function() {
$Init(this, '$MyProperty', $Default({def_Int32}));
{sm_Object}.call(this);
}");
}
public void GetEnumeratorAsStaticMethodWithThisAsFirstArgumentWithEnumerateAsArray()
{
AssertCorrect(
@"public class X {
class MyEnumerable {
public MyEnumerator GetEnumerator() { return null; }
}
sealed class MyEnumerator {
public int Current { get { return 0; } }
public bool MoveNext() {}
}
public void M() {
var enm = new MyEnumerable();
// BEGIN
foreach (var item in enm) {
int x = 0;
}
// END
}",
@" for (var $tmp1 = 0; $tmp1 < $enm.$Length; $tmp1++) {
var $item = $enm[$tmp1];
var $x = 0;
}
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "GetEnumerator" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name, enumerateAsArray: true) : MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void InstanceAutoEventAccessorsImplementedAsStaticMethodsAreCorrectlyCompiled()
{
Compile(new[] { "using System; class C { public event System.EventHandler MyEvent; }" }, metadataImporter: new MockMetadataImporter {
GetEventSemantics = e => EventScriptSemantics.AddAndRemoveMethods(MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("add_" + e.Name), MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("remove_" + e.Name))
});
var adder = FindStaticMethod("C.add_MyEvent");
var remover = FindStaticMethod("C.remove_MyEvent");
AssertCorrect(adder.Definition,
@"function($this, $value) {
$this.$MyEvent = {sm_Delegate}.Combine($this.$MyEvent, $value);
}");
AssertCorrect(remover.Definition,
@"function($this, $value) {
$this.$MyEvent = {sm_Delegate}.Remove($this.$MyEvent, $value);
}");
AssertCorrect(FindClass("C").UnnamedConstructor,
@"function() {
this.$MyEvent = $Default({def_EventHandler});
{sm_Object}.call(this);
}");
}
public void StaticMethodWithThisAsFirstArgumentAppearsOnTheType()
{
var metadataImporter = new MockMetadataImporter {
GetMethodSemantics = method => MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("X")
};
Compile(new[] { "class C { public static void M() {} }" }, metadataImporter: metadataImporter);
FindClass("C").InstanceMethods.Should().BeEmpty();
FindStaticMethod("C.X").Should().NotBeNull();
}
public void ExpandedParamArrayIsFixedAtTheTopOfMethodsForStaticMethodsWithThisAsFirstArgument()
{
AssertCorrect(
@"void M(int a, int b, params int[] c) {}",
@"function($this, $a, $b) {
var $c = Array.prototype.slice.call(arguments, 3);
}", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name, expandParams: true)
});
}
public void StaticMethodWithThisAsFirstArgumentCanBeCompiled()
{
AssertCorrect(@"
int M(int a, string b) {
return a;
}",
@"function($this, $a, $b) {
return $a;
}", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name)
});
}
public void ExpressionLambdaThatUsesThisIsNotBoundInAStaticMethodWithThisAsFirstArgument() {
AssertCorrect(
@"int x;
public void M() {
// BEGIN
Func<int> f = () => x;
// END
}",
@" var $f = function() {
return $this.$x;
};
", metadataImporter: new MockMetadataImporter { GetMethodSemantics = m => MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name) });
}
public void ThisWorksInsideStaticMethodWithThisAsFirstArgument()
{
AssertCorrect(
@"int x;
public void M() {
// BEGIN
int i = x;
// END
}",
@" var $i = $this.$x;
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name)
});
}
public void GenericStaticMethodWithThisAsFirstArgumentWorks()
{
AssertCorrect(
@"void F<T1, T2>(T1 x, int y, T2 z) {}
public void M() {
int a = 0, b = 0;
string c = null;
// BEGIN
F(a, b, c);
// END
}",
@" $InstantiateGenericMethod({sm_C}.$F, {ga_Int32}, {ga_String}).call(null, this, $a, $b, $c);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name) : MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void GlobalMethodWithThisAsFirstArgumentWorks()
{
AssertCorrect(
@"void F(int x, int y, string z) {}
public void M() {
int a = 0, b = 0;
string c = null;
// BEGIN
F(a, b, c);
// END
}",
@" $F(this, $a, $b, $c);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name, isGlobal: true) : MethodScriptSemantics.NormalMethod(m.Name)
});
}
public void ThisWorksInsideAnonymousMethodInsideStaticMethodWithThisAsFirstArgument()
{
// It works like this because the anonymous method conversion will perform the correct bind.
AssertCorrect(
@"int x;
public void M() {
Action a = () => {
// BEGIN
int i = x;
// END
};
}",
@" var $i = $this.$x;
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name)
});
}
public void CanPerformMethodGroupConversionOnStaticMethodWithThisAsFirstArgumentWithoutReturnValue()
{
AssertCorrect(
@"public void F(int a, int b) { return 0; }
public void M() {
// BEGIN
Action<int, int> f = F;
// END
}
",
@" var $f = $Bind(function($tmp1, $tmp2) {
{sm_C}.$F(this, $tmp1, $tmp2);
}, this);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$F") : MethodScriptSemantics.NormalMethod(m.Name)
});
}
public void StaticMethodWithThisAsFirstArgumentDeclaredInGenericTypeWorks()
{
AssertCorrect(
@"class X<TX> { public void F(TX x, int y, string z) {} }
X<int> FX() { return null; }
public void M() {
int a = 0, b = 0;
string c = null;
// BEGIN
FX().F(a, b, c);
// END
}",
@" sm_$InstantiateGenericType({X}, {ga_Int32}).$F(this.$FX(), $a, $b, $c);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name) : MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void MethodGroupConversionOnStaticMethodWithThisAsFirstArgumentOnAnotherTargetWorks()
{
AssertCorrect(
@"public void F(int a, int b) {}
public void M() {
C c;
// BEGIN
Action<int, int> f = c.F;
// END
}
",
@" var $f = $Bind(function($tmp1, $tmp2) {
{sm_C}.$F(this, $tmp1, $tmp2);
}, $c);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$F") : MethodScriptSemantics.NormalMethod(m.Name)
});
}
public void CannotPerformMethodGroupConversionOnStaticMethodWithThisAsFirstArgumentThatExpandsParamsToDelegateThatDoesNot()
{
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;
}
}"
}, metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$F", expandParams: true) : MethodScriptSemantics.NormalMethod(m.Name)
}, errorReporter: er);
Assert.That(er.AllMessages.Count, Is.EqualTo(1));
Assert.That(er.AllMessages[0].FormattedMessage.Contains("C1.F") && er.AllMessages[0].FormattedMessage.Contains("System.Action") && er.AllMessages[0].FormattedMessage.Contains("expand") && er.AllMessages[0].FormattedMessage.Contains("param array"));
}
public void CanPerformMethodGroupConversionOnStaticMethodWithThisAsFirstArgumentInGenericType()
{
AssertCorrect(
@"class C<T1, T2> {
public int F(int a, int b) { return 0; }
public void M() {
// BEGIN
System.Func<int, int, int> f = F;
// END
}
}
",
@" var $f = $Bind(function($tmp1, $tmp2) {
return sm_$InstantiateGenericType({C}, $T1, $T2).$F(this, $tmp1, $tmp2);
}, this);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$F") : MethodScriptSemantics.NormalMethod(m.Name)
}, addSkeleton: false);
}
public void StaticMethodWithThisAsFirstArgumentWorksWithReorderedAndDefaultArguments()
{
AssertCorrect(
@"void F(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() {
// BEGIN
F(d: F1(), g: F2(), f: F3(), b: F4());
// END
}
",
@" var $tmp1 = this.$F1();
var $tmp2 = this.$F2();
var $tmp3 = this.$F3();
{sm_C}.$F(this, 1, this.$F4(), 3, $tmp1, 5, $tmp3, $tmp2);
", metadataImporter: new MockMetadataImporter {
GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$" + m.Name) : MethodScriptSemantics.NormalMethod("$" + m.Name)
});
}
public void InstanceAutoPropertiesWithGetSetMethodsStaticWithNoCodeAreCorrectlyImported()
{
var metadataImporter = new MockMetadataImporter {
GetPropertySemantics = p => PropertyScriptSemantics.GetAndSetMethods(MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("get_" + p.Name, generateCode: false), MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("set_" + p.Name, generateCode: false)),
GetAutoPropertyBackingFieldName = p => { throw new InvalidOperationException("Shouldn't be called"); }
};
Compile(new[] { "class C { public string SomeProp { get; set; } }" }, metadataImporter: metadataImporter);
Assert.That(FindInstanceMethod("C.get_SomeProp"), Is.Null);
Assert.That(FindInstanceMethod("C.set_SomeProp"), Is.Null);
Assert.That(FindStaticMethod("C.get_SomeProp"), Is.Null);
Assert.That(FindStaticMethod("C.set_SomeProp"), Is.Null);
FindClass("C").UnnamedConstructor.Body.Statements.Should().BeEmpty();
Assert.That(FindClass("C").StaticInitStatements, Is.Empty);
}
public void InstanceAutoPropertiesWithGetSetMethodsStaticWithNoCodeAreCorrectlyImported()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.Unnamed(skipInInitializer: c.DeclaringType.IsKnownType(KnownTypeCode.Object)),
GetPropertySemantics = p => PropertyScriptSemantics.GetAndSetMethods(MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("get_" + p.Name, generateCode: false), MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("set_" + p.Name, generateCode: false)),
};
Compile(new[] { "class C { public string SomeProp { get; set; } }" }, metadataImporter: metadataImporter);
Assert.That(FindInstanceMethod("C.get_SomeProp"), Is.Null);
Assert.That(FindInstanceMethod("C.set_SomeProp"), Is.Null);
Assert.That(FindStaticMethod("C.get_SomeProp"), Is.Null);
Assert.That(FindStaticMethod("C.set_SomeProp"), Is.Null);
FindInstanceFieldInitializer("C.$SomeProp").Should().NotBeNull();
Assert.That(FindClass("C").StaticInitStatements, Is.Empty);
}
public void CanPerformMethodGroupConversionOnStaticMethodWithThisAsFirstArgumentWhenBothTheMethodAndTheDelegateTypeExpandsParamArray()
{
AssertCorrect(
@"public void F(int a, int b) { return 0; }
public void M() {
// BEGIN
Action<int, int> f = F;
// END
}
",
@" var $f = $Bind(function() {
{sm_C}.$F.apply(null, [this].concat(Array.prototype.slice.call(arguments)));
}, this);
", metadataImporter: new MockMetadataImporter {
GetDelegateSemantics = d => new DelegateScriptSemantics(expandParams: true), GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$F", expandParams: true) : MethodScriptSemantics.NormalMethod(m.Name)
});
}
public void CanPerformMethodGroupConversionOnStaticMethodWithThisAsFirstArgumentWhenDelegateTypeUsesBindThisToFirstParameter()
{
AssertCorrect(
@"public void F(int a, int b) { return 0; }
public void M() {
// BEGIN
Action<int, int> f = F;
// END
}
",
@" var $f = $BindFirstParameterToThis($Bind(function($tmp1, $tmp2) {
{sm_C}.$F(this, $tmp1, $tmp2);
}, this));
", metadataImporter: new MockMetadataImporter {
GetDelegateSemantics = d => new DelegateScriptSemantics(bindThisToFirstParameter: true), GetMethodSemantics = m => m.Name == "F" ? MethodScriptSemantics.StaticMethodWithThisAsFirstArgument("$F") : MethodScriptSemantics.NormalMethod(m.Name)
});
}