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; "); }