public void FieldConstantInLiftedOperation()
{
AssertCorrect(@"
public void M() {
bool b;
double? d = 0, d2;
// BEGIN
b = d == double.PositiveInfinity;
b = d != double.PositiveInfinity;
b = d >= double.PositiveInfinity;
b = d <= double.PositiveInfinity;
b = d > double.PositiveInfinity;
b = d < double.PositiveInfinity;
d2 = d + double.PositiveInfinity;
d2 = d - double.PositiveInfinity;
d2 = d * double.PositiveInfinity;
d2 = d / double.PositiveInfinity;
// END
}",
@" $b = $d === {sm_Double}.$PosInf;
$b = $d !== {sm_Double}.$PosInf;
$b = $Lift($d >= {sm_Double}.$PosInf);
$b = $Lift($d <= {sm_Double}.$PosInf);
$b = $Lift($d > {sm_Double}.$PosInf);
$b = $Lift($d < {sm_Double}.$PosInf);
$d2 = $Lift($d + {sm_Double}.$PosInf);
$d2 = $Lift($d - {sm_Double}.$PosInf);
$d2 = $Lift($d * {sm_Double}.$PosInf);
$d2 = $Lift($d / {sm_Double}.$PosInf);
", metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.Field("$PosInf")
});
}
public void ReadingFieldImplementedAsConstantWorks()
{
AssertCorrect(
@"
public int F1;
public int F2;
public int F3;
public int F4;
public void M() {
// BEGIN
var f1 = F1;
var f2 = F2;
var f3 = F3;
var f4 = F4;
// END
}",
@" var $f1 = null;
var $f2 = 'abcd';
var $f3 = 1234.5;
var $f4 = true;
", metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : (f.Name == "F2" ? FieldScriptSemantics.StringConstant("abcd") : (f.Name == "F3" ? FieldScriptSemantics.NumericConstant(1234.5) : (f.Name == "F4" ? FieldScriptSemantics.BooleanConstant(true) : FieldScriptSemantics.Field(f.Name))))
});
}
public void SetFieldSemanticsWorks()
{
Prepare(@"public class C { public int TheField; } public class D : C { public new int TheField; }", () => {
Metadata.SetFieldSemantics(FindField("C.TheField"), FieldScriptSemantics.Field("__something_else__"));
});
Assert.AreEqual(Metadata.GetFieldSemantics(FindField("C.TheField")).Name, "__something_else__");
Assert.AreEqual(Metadata.GetFieldSemantics(FindField("D.TheField")).Name, "theField");
}
public void ReadingNotUsableFieldGivesAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] { "class Class { int UnusableField; public void M() { int x = UnusableField; } }" }, metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.NotUsableFromScript()
}, errorReporter: er);
Assert.That(er.AllMessages.Any(msg => msg.Severity == MessageSeverity.Error && msg.FormattedMessage.Contains("Class.UnusableField")));
}
public void ReadingNotUsableFieldGivesAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] { "class Class { int UnusableField; public void M() { int x = UnusableField; } }" }, metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.NotUsableFromScript()
}, errorReporter: er);
Assert.That(er.AllMessagesText.Any(m => m.StartsWith("Error:") && m.Contains("Class.UnusableField")));
}
public void EnumMemberImplementedAsStringConstantIsNotImported()
{
var md = new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "Member2" ? FieldScriptSemantics.StringConstant("a", "$" + f.Name) : FieldScriptSemantics.Field("$" + f.Name)
};
Compile(new[] { "enum MyEnum { Member1, Member2, Member3 }" }, metadataImporter: md);
FindEnum("MyEnum").Values.Select(v => v.Name).Should().BeEquivalentTo(new[] { "$Member1", "$Member3" });
}
public void EnumValueWhichIsNotUsableFromScriptIsNotImported()
{
var md = new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "Member2" ? FieldScriptSemantics.NotUsableFromScript() : FieldScriptSemantics.Field("$" + f.Name)
};
Compile(new[] { "enum MyEnum { Member1, Member2, Member3 }" }, metadataImporter: md);
FindEnum("MyEnum").Values.Select(v => v.Name).Should().BeEquivalentTo(new[] { "$Member1", "$Member3" });
}
public void InstanceFieldsAreCorrectlyImported()
{
var metadataImporter = new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.Field("$SomeProp")
};
Compile(new[] { "class C { public int SomeField; }" }, metadataImporter: metadataImporter);
FindInstanceFieldInitializer("C.$SomeProp").Should().NotBeNull();
FindClass("C").StaticInitStatements.Should().BeEmpty();
FindClass("C").InstanceMethods.Should().BeEmpty();
FindClass("C").StaticMethods.Should().BeEmpty();
}
public void FieldsThatAreNotUsableFromScriptAreNotImported()
{
var metadataImporter = new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.NotUsableFromScript()
};
Compile(new[] { "class C { public int SomeField; }" }, metadataImporter: metadataImporter);
FindClass("C").UnnamedConstructor.Body.Statements.Should().BeEmpty();
FindClass("C").StaticInitStatements.Should().BeEmpty();
FindClass("C").InstanceMethods.Should().BeEmpty();
FindClass("C").StaticMethods.Should().BeEmpty();
}
public void ImportingMultipleFieldsInTheSameDeclarationWorks()
{
var metadataImporter = new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.Field("$" + f.Name)
};
Compile(new[] { "class C { public int Field1, Field2; }" }, metadataImporter: metadataImporter);
FindInstanceFieldInitializer("C.$Field1").Should().NotBeNull();
FindInstanceFieldInitializer("C.$Field2").Should().NotBeNull();
FindClass("C").StaticInitStatements.Should().BeEmpty();
FindClass("C").InstanceMethods.Should().BeEmpty();
FindClass("C").StaticMethods.Should().BeEmpty();
}
public MockMetadataImporter()
{
GetTypeSemantics = t => {
if (t.DeclaringTypeDefinition == null)
{
return(TypeScriptSemantics.NormalType(t.FullName));
}
else
{
return(TypeScriptSemantics.NormalType(GetTypeSemantics(t.DeclaringTypeDefinition).Name + "$" + t.Name));
}
};
GetMethodSemantics = m => MethodScriptSemantics.NormalMethod(m.Name);
GetConstructorSemantics = c => {
if (c.DeclaringType.Kind == TypeKind.Anonymous)
{
return(ConstructorScriptSemantics.Json(new IMember[0]));
}
else if (c.DeclaringType.GetConstructors().Count() == 1 || c.Parameters.Count == 0)
{
return(ConstructorScriptSemantics.Unnamed());
}
else
{
return(ConstructorScriptSemantics.Named("ctor$" + String.Join("$", c.Parameters.Select(p => p.Type.Name))));
}
};
GetPropertySemantics = p => {
if (p.DeclaringType.Kind == TypeKind.Anonymous || (p.DeclaringType.FullName == "System.Array" && p.Name == "Length"))
{
string name = p.Name.Replace("<>", "$");
return(PropertyScriptSemantics.Field(name.StartsWith("$") ? name : ("$" + name)));
}
else
{
return(PropertyScriptSemantics.GetAndSetMethods(MethodScriptSemantics.NormalMethod("get_" + p.Name), MethodScriptSemantics.NormalMethod("set_" + p.Name)));
}
};
GetDelegateSemantics = d => new DelegateScriptSemantics();
GetAutoPropertyBackingFieldName = p => "$" + p.Name;
ShouldGenerateAutoPropertyBackingField = p => true;
GetFieldSemantics = f => FieldScriptSemantics.Field("$" + f.Name);
GetEventSemantics = e => EventScriptSemantics.AddAndRemoveMethods(MethodScriptSemantics.NormalMethod("add_" + e.Name), MethodScriptSemantics.NormalMethod("remove_" + e.Name));
GetAutoEventBackingFieldName = e => "$" + e.Name;
ShouldGenerateAutoEventBackingField = e => true;
}
public void FieldConstantInLiftedOperation()
{
AssertCorrect(@"
public void M() {
bool b;
double? d = 0;
// BEGIN
d += double.PositiveInfinity;
d -= double.PositiveInfinity;
d *= double.PositiveInfinity;
d /= double.PositiveInfinity;
// END
}",
@" $d = $Lift($d + {sm_Double}.$PosInf);
$d = $Lift($d - {sm_Double}.$PosInf);
$d = $Lift($d * {sm_Double}.$PosInf);
$d = $Lift($d / {sm_Double}.$PosInf);
", metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => FieldScriptSemantics.Field("$PosInf")
});
}
public void FieldsImplementedAsConstantsWorkAsCaseLabels()
{
AssertCorrect(
@"enum E { Value1, Value2 }
public void M() {
E e = E.Value1;
// BEGIN
switch (e) {
case E.Value1:
int x = 0;
break;
case E.Value2:
int y = 0;
break;
default:
int z = 0;
break;
}
// END
}",
@" switch ($e) {
case 'Value1': {
var $x = 0;
break;
}
case 'Value2': {
var $y = 0;
break;
}
default: {
var $z = 0;
break;
}
}
", metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => f.DeclaringType.Name == "E" ? FieldScriptSemantics.StringConstant(f.Name) : FieldScriptSemantics.Field(f.Name)
});
}
public void AssigningToFieldImplementedAsConstantIsAnError()
{
var er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public int F1;
public void M() {
// BEGIN
F1 = 1;
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name)
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
er = new MockErrorReporter(false);
Compile(new[] {
@"class C {
public int F1;
public void M() {
// BEGIN
F1 += 1;
// END
}
}"
}, metadataImporter: new MockMetadataImporter {
GetFieldSemantics = f => f.Name == "F1" ? FieldScriptSemantics.NullConstant() : FieldScriptSemantics.Field(f.Name)
}, errorReporter: er);
Assert.That(er.AllMessagesText.Count, Is.EqualTo(1));
Assert.That(er.AllMessagesText.Any(m => m.Contains("C.F1") && m.Contains("cannot be assigned to")));
}
void IMetadataImporter.SetFieldSemantics(IField field, FieldScriptSemantics semantics)
{
}
public virtual void SetFieldSemantics(IField field, FieldScriptSemantics semantics)
{
_prev.SetFieldSemantics(field, semantics);
}
public void StaticFieldsAreCorrectlyImported()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.Unnamed(skipInInitializer: c.DeclaringType.IsKnownType(KnownTypeCode.Object)), GetFieldSemantics = f => FieldScriptSemantics.Field("$SomeProp")
};
Compile(new[] { "class C { public static int SomeField; }" }, metadataImporter: metadataImporter);
FindStaticFieldInitializer("C.$SomeProp").Should().NotBeNull();
FindClass("C").UnnamedConstructor.Body.Statements.Should().BeEmpty();
FindClass("C").InstanceMethods.Should().BeEmpty();
FindClass("C").StaticMethods.Should().BeEmpty();
}
public void FieldsThatAreNotUsableFromScriptAreNotImported()
{
var metadataImporter = new MockMetadataImporter {
GetConstructorSemantics = c => ConstructorScriptSemantics.Unnamed(skipInInitializer: c.DeclaringType.IsKnownType(KnownTypeCode.Object)), GetFieldSemantics = f => FieldScriptSemantics.NotUsableFromScript()
};
Compile(new[] { "class C { public int SomeField; }" }, metadataImporter: metadataImporter);
FindClass("C").UnnamedConstructor.Body.Statements.Should().BeEmpty();
FindClass("C").StaticInitStatements.Should().BeEmpty();
FindClass("C").InstanceMethods.Should().BeEmpty();
FindClass("C").StaticMethods.Should().BeEmpty();
}
