public void InvokingParamArrayGenericMethodThatExpandsArgumentsInNonExpandedFormWorks()
{
SourceVerifier.AssertSourceCorrect(
@"using System.Runtime.CompilerServices;
public class B {
[ExpandParams] public virtual void F1<T>(int x, int y, params int[] args) {}
[ExpandParams] public virtual void F2<T>(int x, params int[] args) {}
[ExpandParams] public virtual void F3<T>(params int[] args) {}
}
public class C : B {
[ExpandParams] public override void F1<T>(int x, int y, params int[] args) {}
[ExpandParams] public override void F2<T>(int x, params int[] args) {}
[ExpandParams] public override void F3<T>(params int[] args) {}
public void M() {
C c = null;
var args = new[] { 59, 12, 4 };
// BEGIN
base.F1<int>(4, 8, args);
base.F2<int>(42, args);
base.F3<int>(args);
base.F1<int>(4, 8, new[] { 59, 12, 4 });
// END
}
}",
@" $B.prototype.f1(ss.Int32).apply(this, [4, 8].concat(args));
$B.prototype.f2(ss.Int32).apply(this, [42].concat(args));
$B.prototype.f3(ss.Int32).apply(this, args);
$B.prototype.f1(ss.Int32).call(this, 4, 8, 59, 12, 4);
");
}
public void CastBetweenTypesWithTheSameScriptNameIsANoOp()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
using System.Runtime.CompilerServices;
[ScriptName(""X"")]
class C1 {}
[ScriptName(""X"")]
class C2 : C1 {}
public class C {
private void M() {
C1 o = null;
// BEGIN
var v1 = (C2)o;
var v2 = o as C2;
var v3 = o is C2;
// END
}
}",
@" var v1 = o;
var v2 = o;
var v3 = ss.isValue(o);
");
}
public void AsOperatorWorksForImportedTypeWithTypeCheckCode()
{
SourceVerifier.AssertSourceCorrect(@"
using System.Runtime.CompilerServices;
[Imported(TypeCheckCode = ""true"")] public class C1 {}
[Imported(TypeCheckCode = ""{this}.x"")] public class C2 {}
[Imported(TypeCheckCode = ""{this}.x || {this}.y"")] public class C3 {}
[Imported(TypeCheckCode = ""{this}.x == {T}"")] public class C4<T> {}
public class C {
private object GetO() { return null; }
private void M() {
object o = null;
// BEGIN
var o1 = o as C1;
var o2 = o as C2;
var o3 = o as C3;
var o4 = GetO() as C1;
var o5 = GetO() as C2;
var o6 = GetO() as C3;
var o7 = o as C4<int>;
// END
}
}",
@" var o1 = ss.safeCast(o, ss.isValue(o) && true);
var o2 = ss.safeCast(o, ss.isValue(o) && o.x);
var o3 = ss.safeCast(o, ss.isValue(o) && (o.x || o.y));
var $t1 = this.$getO();
var o4 = ss.safeCast($t1, ss.isValue($t1) && true);
var $t2 = this.$getO();
var o5 = ss.safeCast($t2, ss.isValue($t2) && $t2.x);
var $t3 = this.$getO();
var o6 = ss.safeCast($t3, ss.isValue($t3) && ($t3.x || $t3.y));
var o7 = ss.safeCast(o, ss.isValue(o) && o.x == ss.Int32);
");
}
public void CanCompileCodeWithNonAsciiCharacters()
{
SourceVerifier.AssertSourceCorrect(
@"namespace Ф {
public class Класс {
void Я() {
string Щ = ""г"";
}
}
}",
@"(function() {
'use strict';
var $asm = {};
global.Ф = global.Ф || {};
ss.initAssembly($asm, 'x');
////////////////////////////////////////////////////////////////////////////////
// Ф.Класс
var $Ф_Класс = function() {
};
$Ф_Класс.__typeName = 'Ф.Класс';
global.Ф.Класс = $Ф_Класс;
ss.initClass($Ф_Класс, $asm, {
$я: function() {
var Щ = 'г';
}
});
})();
");
}
public void IsOperatorWorksForImportedTypeWithTypeCheckCode()
{
SourceVerifier.AssertSourceCorrect(@"
using System.Runtime.CompilerServices;
[Imported(TypeCheckCode = ""true"")] public class C1 {}
[Imported(TypeCheckCode = ""{this}.x"")] public class C2 {}
[Imported(TypeCheckCode = ""{this}.x || {this}.y"")] public class C3 {}
[Imported(TypeCheckCode = ""{this}.x == {T}"")] public class C4<T> {}
public class C {
private object GetO() { return null; }
private void M() {
object o = null;
// BEGIN
bool b1 = o is C1;
bool b2 = o is C2;
bool b3 = o is C3;
bool b4 = GetO() is C1;
bool b5 = GetO() is C2;
bool b6 = GetO() is C3;
bool b7 = o is C4<int>;
// END
}
}",
@" var b1 = ss.isValue(o) && true;
var b2 = ss.isValue(o) && o.x;
var b3 = ss.isValue(o) && (o.x || o.y);
var b4 = ss.isValue(this.$getO()) && true;
var $t1 = this.$getO();
var b5 = ss.isValue($t1) && $t1.x;
var $t2 = this.$getO();
var b6 = ss.isValue($t2) && ($t2.x || $t2.y);
var b7 = ss.isValue(o) && o.x == ss.Int32;
");
}
public void UpcastCharToObjectIsAnError()
{
var result = SourceVerifier.Compile(@"
public class C {
public static void M() {
string s = ""X"" + 'c';
}
}", expectErrors: true);
Assert.That(result.Item2.AllMessages.Select(m => m.Code), Is.EqualTo(new[] { 7700 }));
}
public void CannotUseTheAsOperatorWithSerializableTypeWithoutTypeCheckCode()
{
var actual = SourceVerifier.Compile(@"
[System.Serializable] class C1 {}
class C {
public void M() {
var x = new object() as C1;
}
}
", expectErrors: true);
Assert.That(actual.Item2.AllMessages.Count, Is.EqualTo(1));
Assert.That(actual.Item2.AllMessages.Any(m => m.Severity == MessageSeverity.Error && m.Code == 7702 && m.FormattedMessage.Contains("'as' operator") && m.FormattedMessage.Contains("C1")));
}
public void CannotUseTheAsOperatorWithImportedTypeThatDoesNotObeyTheTypeSystemOrHaveTypeCheckCode()
{
var actual = SourceVerifier.Compile(@"
[System.Runtime.CompilerServices.Imported] class C1 {}
class C {
public void M() {
var x = new object() as C1;
}
}
", expectErrors: true);
Assert.That(actual.Item2.AllMessages.Count, Is.EqualTo(1));
Assert.That(actual.Item2.AllMessages.Any(m => m.Severity == MessageSeverity.Error && m.Code == 7702 && m.FormattedMessage.Contains("'as' operator") && m.FormattedMessage.Contains("C1")));
}
public void TypeOfArrayTypeReturnsArray()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
class C {
public void M() {
// BEGIN
var t = typeof(int[]);
// END
}
}
",
@" var t = Array;
");
}
public void CanUseStaticMemberOfSerializableParameterizedTypeWithIgnoreGenericArguments()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Serializable, System.Runtime.CompilerServices.IncludeGenericArguments(false)] public class G<T1, T2> { public static void M() {} }
class C {
public void M() {
// BEGIN
G<object, string>.M();
// END
}
}
",
@" $G.m();
");
}
public void DefaultValueOfStruct()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
public class C {
private void M() {
// BEGIN
var v = default(TimeSpan);
// END
}
}",
@" var v = ss.getDefaultValue(ss.TimeSpan);
");
}
public void CanUseStaticMemberOfSerializableParameterizedType()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Serializable] public class G<T1, T2> { public static void M() {} }
class C {
public void M() {
// BEGIN
G<object, string>.M();
// END
}
}
",
@" ss.makeGenericType($G$2, [Object, String]).m();
");
}
public void SerializableParameterizedTypeWorksWhenUsedWithTypeOf()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Serializable] public class G<T1, T2> {}
class C {
public void M() {
// BEGIN
var t = typeof(G<object, string>);
// END
}
}
",
@" var t = ss.makeGenericType($G$2, [Object, String]);
");
}
public void CanUseStaticMemberOfImportedParameterizedType()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Runtime.CompilerServices.Imported] public class G<T1, T2> { public static void M() {} }
class C {
public void M() {
// BEGIN
G<object, string>.M();
// END
}
}
",
@" G.m();
");
}
public void ImportedParameterizedTypeWorksWhenUsedWithTypeOf()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Runtime.CompilerServices.Imported] public class G<T1, T2> {}
class C {
public void M() {
// BEGIN
var t = typeof(G<object, string>);
// END
}
}
",
@" var t = G;
");
}
public void TypeOfDelegateTypeReturnsFunction()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
class C {
public void M() {
// BEGIN
var t = typeof(Func<int, string>);
// END
}
}
",
@" var t = Function;
");
}
public void ParameterizedTypeAppearsAsItselfWhenUsedAsGenericArgument()
{
SourceVerifier.AssertSourceCorrect(@"
public class G<T1> {}
class C {
public void M() {
// BEGIN
var f = new G<G<int>>();
// END
}
}
",
@" var f = new (ss.makeGenericType($G$1, [ss.makeGenericType($G$1, [ss.Int32])]))();
");
}
public void TypeOfDynamicReturnsObject()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
class C {
public void M() {
// BEGIN
var t = typeof(dynamic);
// END
}
}
",
@" var t = Object;
");
}
public void SerializableParameterizedTypeWithIgnoreGenericArgumentsWorksWhenUsedWithTypeOf()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Serializable, System.Runtime.CompilerServices.IncludeGenericArguments(false)] public class G<T1, T2> {}
class C {
public void M() {
// BEGIN
var t = typeof(G<object, string>);
// END
}
}
",
@" var t = $G;
");
}
public void InvokingParamArrayMethodThatDoesNotExpandArgumentsInNonExpandedFormWorks()
{
SourceVerifier.AssertSourceCorrect(
@"public class B { public virtual void F(int x, int y, params int[] args) {} }
public class C : B {
public override void F(int x, int y, params int[] args) {}
public void M() {
// BEGIN
base.F(4, 8, new[] { 59, 12, 4 });
// END
}
}",
@" $B.prototype.f.call(this, 4, 8, [59, 12, 4]);
");
}
public void CastingToSerializableParameterizedTypeWithIgnoreGenericArgumentsIsANoOp()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Serializable, System.Runtime.CompilerServices.IncludeGenericArguments(false)] public class G<T1, T2> { public void M() {} }
class C {
public void M() {
object o = null;
// BEGIN
var g = (G<object, string>)o;
// END
}
}
",
@" var g = o;
");
}
public void SerializableParameterizedTypeWithIgnoreGenericArgumentsAppearsAsItselfWhenUsedAsInlineCodeGenericArgument()
{
SourceVerifier.AssertSourceCorrect(@"
[System.Serializable, System.Runtime.CompilerServices.IncludeGenericArguments(false)] public class G2<T1> {}
class C {
[System.Runtime.CompilerServices.InlineCode(""{T}"")] public object F<T>() {}
public void M() {
// BEGIN
var x = F<G2<int>>();
// END
}
}
",
@" var x = $G2;
");
}
public void SerializableParameterizedTypeWithIgnoreGenericArgumentsAppearsAsItselfWhenUsedAsGenericArgument()
{
SourceVerifier.AssertSourceCorrect(@"
public class G<T1> {}
[System.Serializable, System.Runtime.CompilerServices.IncludeGenericArguments(false)] public class G2<T1> {}
class C {
public void M() {
// BEGIN
var f = new G<G2<int>>();
// END
}
}
",
@" var f = new (ss.makeGenericType($G$1, [$G2]))();
");
}
public void TypeOfTypeDefinitionWorks()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
public class X {}
class C {
public void M() {
// BEGIN
var t = typeof(X);
// END
}
}
",
@" var t = $X;
");
}
public void ArrayTypeAppearsAsArrayAsGenericArgument()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
class G<T> {}
class C {
public void M() {
// BEGIN
var f = new G<int[]>();
// END
}
}
",
@" var f = new (ss.makeGenericType($$G$1, [Array]))();
");
}
public void ArrayTypeAppearsAsArrayAsTypeArgumentInInlineCode()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
class C {
[System.Runtime.CompilerServices.InlineCode(""{T}"")] public object F<T>() {}
public void M() {
// BEGIN
var x = F<int[]>();
// END
}
}
",
@" var x = Array;
");
}
public void InvokingStaticMethodOfImportedTypeDefinitionWorks()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
[System.Runtime.CompilerServices.Imported] public class X { public static void M() {} }
class C {
public void M() {
// BEGIN
X.M();
// END
}
}
",
@" X.m();
");
}
public void InvokingStaticMethodOfTypeDefinitionWorks()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
public class X { public static void M() {} }
class C {
public void M() {
// BEGIN
X.M();
// END
}
}
",
@" $X.m();
");
}
public void TypeOfSerializableTypeDefinitionWorks()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
[System.Serializable] public class X {}
class C {
public void M() {
// BEGIN
var f = typeof(X);
// END
}
}
",
@" var f = $X;
");
}
public void TypeOfImportedTypeDefinitionThatObeysTheTypeSystemReturnsItself()
{
SourceVerifier.AssertSourceCorrect(@"
using System;
[System.Runtime.CompilerServices.Imported(ObeysTypeSystem=true)] public class X {}
class C {
public void M() {
// BEGIN
var t = typeof(X);
// END
}
}
",
@" var t = X;
");
}
