diff --git a/src/Core/Compiler/Compiler/MetadataBuilder.cs b/src/Core/Compiler/Compiler/MetadataBuilder.cs index d846598f0..b3ba51d1e 100644 --- a/src/Core/Compiler/Compiler/MetadataBuilder.cs +++ b/src/Core/Compiler/Compiler/MetadataBuilder.cs @@ -265,47 +265,16 @@ private void BuildMemberDetails(MemberSymbol memberSymbol, TypeSymbol typeSymbol memberSymbol.SetVisibility(GetVisibility(memberNode, typeSymbol)); } - AttributeNode nameAttribute = AttributeNode.FindAttribute(attributes, "ScriptName"); - if ((nameAttribute != null) && (nameAttribute.Arguments != null) && - (nameAttribute.Arguments.Count != 0)) { - string name = null; - bool preserveCase = false; - bool preserveName = false; - - foreach (ParseNode argNode in nameAttribute.Arguments) { - Debug.Assert((argNode.NodeType == ParseNodeType.Literal) || - (argNode.NodeType == ParseNodeType.BinaryExpression)); - - if (argNode.NodeType == ParseNodeType.Literal) { - Debug.Assert(((LiteralNode)argNode).Value is string); - name = (string)((LiteralNode)argNode).Value; - preserveName = preserveCase = true; - break; - } - else { - BinaryExpressionNode propSetNode = (BinaryExpressionNode)argNode; - - if (String.CompareOrdinal(((NameNode)propSetNode.LeftChild).Name, "PreserveName") == 0) { - preserveName = (bool)((LiteralNode)propSetNode.RightChild).Value; - } - else { - preserveCase = (bool)((LiteralNode)propSetNode.RightChild).Value; - if (preserveCase) { - preserveName = true; - break; - } - } - } - } - - if (String.IsNullOrEmpty(name) == false) { - memberSymbol.SetTransformedName(name); - } - else { - memberSymbol.SetNameCasing(preserveCase); - if (preserveName) { - memberSymbol.DisableNameTransformation(); - } + bool preserveCase; + bool preserveName; + string name = GetScriptName(attributes, typeSymbol.MemberCasePreservation, out preserveName, out preserveCase); + + if (String.IsNullOrEmpty(name) == false) { + memberSymbol.SetTransformedName(name); + } else { + memberSymbol.SetNameCasing(preserveCase); + if (preserveName) { + memberSymbol.DisableNameTransformation(); } } } @@ -412,6 +381,8 @@ public ICollection BuildMetadata(ParseNodeList compilationUnits, Sym _options = options; BuildAssembly(compilationUnits); + bool defaultMemberCasePreservation = GetDefaultMemberCasePreservation(compilationUnits); + List types = new List(); // Build all the types first. @@ -495,11 +466,11 @@ public ICollection BuildMetadata(ParseNodeList compilationUnits, Sym // Merge interesting bits of information onto the primary type symbol as well // representing this partial class - BuildType(partialTypeSymbol, userTypeNode); + BuildType(partialTypeSymbol, userTypeNode, defaultMemberCasePreservation); } } - TypeSymbol typeSymbol = BuildType(userTypeNode, namespaceSymbol); + TypeSymbol typeSymbol = BuildType(userTypeNode, namespaceSymbol, defaultMemberCasePreservation); if (typeSymbol != null) { typeSymbol.SetParseContext(userTypeNode); typeSymbol.SetParentSymbolTable(symbols); @@ -754,7 +725,7 @@ private void BuildResources(ResourcesSymbol resourcesSymbol) { } } - private TypeSymbol BuildType(UserTypeNode typeNode, NamespaceSymbol namespaceSymbol) { + private TypeSymbol BuildType(UserTypeNode typeNode, NamespaceSymbol namespaceSymbol, bool defaultMemberCasePreservation) { Debug.Assert(typeNode != null); Debug.Assert(namespaceSymbol != null); @@ -810,7 +781,7 @@ private TypeSymbol BuildType(UserTypeNode typeNode, NamespaceSymbol namespaceSym typeSymbol.SetPublic(); } - BuildType(typeSymbol, typeNode); + BuildType(typeSymbol, typeNode, defaultMemberCasePreservation); if (namespaceSymbol.Name.EndsWith(".Tests", StringComparison.Ordinal) || (namespaceSymbol.Name.IndexOf(".Tests.", StringComparison.Ordinal) > 0)) { @@ -821,7 +792,7 @@ private TypeSymbol BuildType(UserTypeNode typeNode, NamespaceSymbol namespaceSym return typeSymbol; } - private void BuildType(TypeSymbol typeSymbol, UserTypeNode typeNode) { + private void BuildType(TypeSymbol typeSymbol, UserTypeNode typeNode, bool defaultMemberCasePreservation) { Debug.Assert(typeSymbol != null); Debug.Assert(typeNode != null); @@ -869,11 +840,16 @@ private void BuildType(TypeSymbol typeSymbol, UserTypeNode typeNode) { typeSymbol.DisableNameTransformation(); } - string scriptName = GetAttributeValue(attributes, "ScriptName"); + bool preserveCase; + bool dummy; + string scriptName = GetScriptName(attributes, defaultMemberCasePreservation, out dummy, out preserveCase); + if (scriptName != null) { typeSymbol.SetTransformedName(scriptName); } + typeSymbol.MemberCasePreservation = preserveCase; + if (typeNode.Type == TokenType.Class) { AttributeNode extensionAttribute = AttributeNode.FindAttribute(attributes, "ScriptExtension"); if (extensionAttribute != null) { @@ -992,6 +968,45 @@ private string GetAssemblyScriptName(ParseNodeList compilationUnits) { return null; } + private string GetScriptName(ParseNodeList attributes, bool defaultMemberCasePreservation, out bool preserveName, out bool preserveCase) { + + string name = null; + preserveCase = defaultMemberCasePreservation; + preserveName = false; + + AttributeNode nameAttribute = AttributeNode.FindAttribute(attributes, "ScriptName"); + + if ((nameAttribute != null) && (nameAttribute.Arguments != null) && + (nameAttribute.Arguments.Count != 0)) { + + foreach (ParseNode argNode in nameAttribute.Arguments) { + Debug.Assert((argNode.NodeType == ParseNodeType.Literal) || + (argNode.NodeType == ParseNodeType.BinaryExpression)); + + if (argNode.NodeType == ParseNodeType.Literal) { + Debug.Assert(((LiteralNode)argNode).Value is string); + name = (string)((LiteralNode)argNode).Value; + preserveName = preserveCase = true; + break; + } else { + BinaryExpressionNode propSetNode = (BinaryExpressionNode)argNode; + + if (String.CompareOrdinal(((NameNode)propSetNode.LeftChild).Name, "PreserveName") == 0) { + preserveName = (bool)((LiteralNode)propSetNode.RightChild).Value; + } else { + preserveCase = (bool)((LiteralNode)propSetNode.RightChild).Value; + if (preserveCase) { + preserveName = true; + break; + } + } + } + } + } + + return name; + } + private List GetAttributes(ParseNodeList compilationUnits, string attributeName) { List attributes = new List(); @@ -1020,6 +1035,18 @@ private string GetAttributeValue(ParseNodeList attributes, string attributeName) return null; } + private bool? GetBoolAttributeValue(ParseNodeList attributes, string attributeName) { + AttributeNode node = AttributeNode.FindAttribute(attributes, attributeName); + + if ((node != null) && + (node.Arguments.Count != 0) && (node.Arguments[0].NodeType == ParseNodeType.Literal)) { + Debug.Assert(((LiteralNode)node.Arguments[0]).Value is bool); + + return (bool)((LiteralNode)node.Arguments[0]).Value; + } + return null; + } + private bool GetScriptTemplate(ParseNodeList compilationUnits, out string template) { template = null; @@ -1035,6 +1062,18 @@ private bool GetScriptTemplate(ParseNodeList compilationUnits, out string templa return false; } + private bool GetDefaultMemberCasePreservation(ParseNodeList compilationUnits) { + foreach (CompilationUnitNode compilationUnit in compilationUnits) { + foreach (AttributeBlockNode attribBlock in compilationUnit.Attributes) { + bool? preserveMemberCase = GetBoolAttributeValue(attribBlock.Attributes, "ScriptDefaultMemberCasePreservation"); + if (preserveMemberCase != null) { + return (bool)preserveMemberCase; + } + } + } + return false; + } + private MemberVisibility GetVisibility(MemberNode node, TypeSymbol typeSymbol) { if (typeSymbol.Type == SymbolType.Interface) { return MemberVisibility.Public; diff --git a/src/Core/Compiler/Importer/MetadataHelpers.cs b/src/Core/Compiler/Importer/MetadataHelpers.cs index 1659915f4..9175d5672 100644 --- a/src/Core/Compiler/Importer/MetadataHelpers.cs +++ b/src/Core/Compiler/Importer/MetadataHelpers.cs @@ -29,6 +29,10 @@ private static string GetAttributeArgument(CustomAttribute attribute) { return attribute.ConstructorArguments[0].Value as string; } + private static bool GetBoolAttributeArgument(CustomAttribute attribute) { + return (bool)attribute.ConstructorArguments[0].Value; + } + public static string GetScriptAlias(ICustomAttributeProvider attributeProvider) { CustomAttribute scriptAliasAttribute = GetAttribute(attributeProvider, "System.Runtime.CompilerServices.ScriptAliasAttribute"); if (scriptAliasAttribute != null) { @@ -54,6 +58,14 @@ public static string GetScriptAssemblyName(ICustomAttributeProvider attributePro return null; } + public static bool GetScriptDefaultMemberCasePreservation(ICustomAttributeProvider attributeProvider) { + CustomAttribute memberCasePreservationAttribute = GetAttribute(attributeProvider, "System.ScriptDefaultMemberCasePreservation"); + if (memberCasePreservationAttribute != null) { + return GetBoolAttributeArgument(memberCasePreservationAttribute); + } + return false; + } + public static string GetScriptDependencyName(ICustomAttributeProvider attributeProvider, out string dependencyIdentifier) { dependencyIdentifier = null; @@ -94,9 +106,9 @@ public static string GetScriptMethodSelector(MethodDefinition method) { return null; } - public static string GetScriptName(ICustomAttributeProvider attributeProvider, out bool preserveName, out bool preserveCase) { + public static string GetScriptName(ICustomAttributeProvider attributeProvider, bool defaultPreserveCaseValue, out bool preserveName, out bool preserveCase) { string name = null; - preserveName = false; + preserveName = defaultPreserveCaseValue; preserveCase = false; CustomAttribute nameAttribute = GetAttribute(attributeProvider, "System.ScriptNameAttribute"); diff --git a/src/Core/Compiler/Importer/MetadataImporter.cs b/src/Core/Compiler/Importer/MetadataImporter.cs index ae0004ddb..3636be68c 100644 --- a/src/Core/Compiler/Importer/MetadataImporter.cs +++ b/src/Core/Compiler/Importer/MetadataImporter.cs @@ -179,7 +179,7 @@ private void ImportEnumFields(TypeSymbol enumTypeSymbol) { EnumerationFieldSymbol fieldSymbol = new EnumerationFieldSymbol(fieldName, enumTypeSymbol, field.Constant, fieldType); - ImportMemberDetails(fieldSymbol, null, field); + ImportMemberDetails(fieldSymbol, enumTypeSymbol, null, field); enumTypeSymbol.AddMember(fieldSymbol); } @@ -207,7 +207,7 @@ private void ImportEvents(TypeSymbol typeSymbol) { } EventSymbol eventSymbol = new EventSymbol(eventName, typeSymbol, eventHandlerType); - ImportMemberDetails(eventSymbol, eventDef.AddMethod, eventDef); + ImportMemberDetails(eventSymbol, typeSymbol, eventDef.AddMethod, eventDef); string addAccessor; string removeAccessor; @@ -251,13 +251,13 @@ private void ImportFields(TypeSymbol typeSymbol) { FieldSymbol fieldSymbol = new FieldSymbol(fieldName, typeSymbol, fieldType); fieldSymbol.SetVisibility(visibility); - ImportMemberDetails(fieldSymbol, null, field); + ImportMemberDetails(fieldSymbol, typeSymbol, null, field); typeSymbol.AddMember(fieldSymbol); } } - private void ImportMemberDetails(MemberSymbol memberSymbol, MethodDefinition methodDefinition, ICustomAttributeProvider attributeProvider) { + private void ImportMemberDetails(MemberSymbol memberSymbol, TypeSymbol typeSymbol, MethodDefinition methodDefinition, ICustomAttributeProvider attributeProvider) { if (methodDefinition != null) { MemberVisibility visibility = MemberVisibility.PrivateInstance; if (methodDefinition.IsStatic) { @@ -275,7 +275,7 @@ private void ImportMemberDetails(MemberSymbol memberSymbol, MethodDefinition met bool preserveName; bool preserveCase; - string scriptName = MetadataHelpers.GetScriptName(attributeProvider, out preserveName, out preserveCase); + string scriptName = MetadataHelpers.GetScriptName(attributeProvider, typeSymbol.MemberCasePreservation, out preserveName, out preserveCase); memberSymbol.SetNameCasing(preserveCase); if (scriptName != null) { @@ -360,7 +360,7 @@ private void ImportMethods(TypeSymbol typeSymbol) { } MethodSymbol methodSymbol = new MethodSymbol(methodName, typeSymbol, returnType); - ImportMemberDetails(methodSymbol, method, method); + ImportMemberDetails(methodSymbol, typeSymbol, method, method); if (method.HasGenericParameters) { List genericArguments = new List(); @@ -434,7 +434,7 @@ private void ImportProperties(TypeSymbol typeSymbol) { PropertySymbol propertySymbol = null; if (property.Parameters.Count != 0) { IndexerSymbol indexerSymbol = new IndexerSymbol(typeSymbol, propertyType); - ImportMemberDetails(indexerSymbol, property.GetMethod, property); + ImportMemberDetails(indexerSymbol, typeSymbol, property.GetMethod, property); if (scriptField) { indexerSymbol.SetScriptIndexer(); @@ -451,7 +451,7 @@ private void ImportProperties(TypeSymbol typeSymbol) { // instead of a property FieldSymbol fieldSymbol = new FieldSymbol(propertyName, typeSymbol, propertyType); - ImportMemberDetails(fieldSymbol, property.GetMethod, property); + ImportMemberDetails(fieldSymbol, typeSymbol, property.GetMethod, property); string alias = MetadataHelpers.GetScriptAlias(property); if (String.IsNullOrEmpty(alias) == false) { @@ -462,7 +462,7 @@ private void ImportProperties(TypeSymbol typeSymbol) { } else { propertySymbol = new PropertySymbol(propertyName, typeSymbol, propertyType); - ImportMemberDetails(propertySymbol, property.GetMethod, property); + ImportMemberDetails(propertySymbol, typeSymbol, property.GetMethod, property); } } @@ -577,13 +577,15 @@ private void ImportScriptAssembly(MetadataSource mdSource, string assemblyPath, scriptNamespace = dependency.Identifier; } + bool defaultMemberCasePreservation = MetadataHelpers.GetScriptDefaultMemberCasePreservation(assembly); + foreach (TypeDefinition type in assembly.MainModule.Types) { try { if (MetadataHelpers.IsCompilerGeneratedType(type)) { continue; } - ImportType(mdSource, type, coreAssembly, scriptNamespace); + ImportType(mdSource, type, coreAssembly, scriptNamespace, defaultMemberCasePreservation); } catch (Exception e) { Debug.Fail(e.ToString()); @@ -591,7 +593,7 @@ private void ImportScriptAssembly(MetadataSource mdSource, string assemblyPath, } } - private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScriptCoreAssembly, string scriptNamespace) { + private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScriptCoreAssembly, string scriptNamespace, bool defaultMemberCasePreservation) { if (type.IsPublic == false) { return; } @@ -603,7 +605,8 @@ private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScr string namespaceName = type.Namespace; bool dummy; - string scriptName = MetadataHelpers.GetScriptName(type, out dummy, out dummy); + bool memberCasePreservation; + string scriptName = MetadataHelpers.GetScriptName(type, defaultMemberCasePreservation, out dummy, out memberCasePreservation); NamespaceSymbol namespaceSymbol = _symbols.GetNamespace(namespaceName); TypeSymbol typeSymbol = null; @@ -683,6 +686,8 @@ private void ImportType(MetadataSource mdSource, TypeDefinition type, bool inScr typeSymbol.SetTransformedName(scriptName); } + typeSymbol.MemberCasePreservation = memberCasePreservation; + namespaceSymbol.AddType(typeSymbol); _importedTypes.Add(typeSymbol); } diff --git a/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs b/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs index 5a42280cf..636ad439d 100644 --- a/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs +++ b/src/Core/Compiler/ScriptModel/Symbols/TypeSymbol.cs @@ -33,6 +33,7 @@ internal abstract class TypeSymbol : Symbol, ISymbolTable { private bool _ignoreNamespace; private string _scriptNamespace; private bool _testType; + private bool _memberCasePreservation; protected TypeSymbol(SymbolType type, string name, NamespaceSymbol parent) : base(type, name, parent) { @@ -195,6 +196,20 @@ public string ScriptNamespace { } } + /// + /// The casing of this type's members names is preserved + /// according to this value unless overriden through a + /// ScriptName attribute on the member. + /// + public bool MemberCasePreservation { + get { + return _memberCasePreservation; + } + set { + _memberCasePreservation = value; + } + } + public virtual void AddMember(MemberSymbol memberSymbol) { Debug.Assert(memberSymbol != null); Debug.Assert(String.IsNullOrEmpty(memberSymbol.Name) == false); diff --git a/src/Core/CoreLib/ScriptMetadata.cs b/src/Core/CoreLib/ScriptMetadata.cs index 3d0412ec8..3680beea2 100644 --- a/src/Core/CoreLib/ScriptMetadata.cs +++ b/src/Core/CoreLib/ScriptMetadata.cs @@ -359,4 +359,23 @@ public string RemoveAccessor { } } } + + [AttributeUsage(AttributeTargets.Assembly)] + [ScriptIgnore] + public sealed class ScriptDefaultMemberCasePreservation : Attribute { + private bool _preserveMemberCase; + + public ScriptDefaultMemberCasePreservation(bool preserveMemberCase) { + _preserveMemberCase = preserveMemberCase; + } + + public bool PerserveMemberCase { + get { + return _preserveMemberCase; + } + set { + _preserveMemberCase = value; + } + } + } } diff --git a/tests/CasePreservationTests.cs b/tests/CasePreservationTests.cs new file mode 100644 index 000000000..96841aeff --- /dev/null +++ b/tests/CasePreservationTests.cs @@ -0,0 +1,50 @@ +// CasePreservationTests.cs +// Script#/Tests +// This source code is subject to terms and conditions of the Apache License, Version 2.0. +// + +using System; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using ScriptSharp.Tests.Core; + +namespace ScriptSharp.Tests { + + [TestClass] + public class CasePreservationTests : CompilationTest { + + [TestMethod] + public void TestDefaultCase() { + RunTest((c) => { + c.AddSource("Code.cs"); + }); + } + + [TestMethod] + public void TestAllMembersCasePreserved() { + RunTest((c) => { + c.AddSource("Code.cs"); + }); + } + + [TestMethod] + public void TestNoMemberCasePreserved() { + RunTest((c) => { + c.AddSource("Code.cs"); + }); + } + + [TestMethod] + public void TestOneTypesMembersCaseNotPreserved() { + RunTest((c) => { + c.AddSource("Code.cs"); + }); + } + + [TestMethod] + public void TestOneMemberCaseNotPreserved() { + RunTest((c) => { + c.AddSource("Code.cs"); + }); + } + } +} diff --git a/tests/TestCases/CasePreservation/AllMembersCasePreserved/Baseline.txt b/tests/TestCases/CasePreservation/AllMembersCasePreserved/Baseline.txt new file mode 100644 index 000000000..c17faab99 --- /dev/null +++ b/tests/TestCases/CasePreservation/AllMembersCasePreserved/Baseline.txt @@ -0,0 +1,43 @@ +"use strict"; + +define('test', ['ss'], function(ss) { + var $global = this; + + // CasePreservationTests.Foo + + function Foo(i, j) { + } + var Foo$ = { + ToString: function() { + return 'Foo'; + }, + Sum: function(i) { + return 0; + } + }; + + + // CasePreservationTests.Bar + + function Bar(i, j, f) { + Foo.call(this, i, j); + } + var Bar$ = { + Sum: function() { + return Foo.prototype.Sum.call(this, 1) + 1; + }, + ToString: function() { + return Foo.prototype.ToString.call(this) + ' -> Bar'; + } + }; + + + var $exports = ss.module('test', null, + { + Foo: [ Foo, Foo$, null ], + Bar: [ Bar, Bar$, Foo ] + }); + + + return $exports; +}); diff --git a/tests/TestCases/CasePreservation/AllMembersCasePreserved/Code.cs b/tests/TestCases/CasePreservation/AllMembersCasePreserved/Code.cs new file mode 100644 index 000000000..25f6c55a7 --- /dev/null +++ b/tests/TestCases/CasePreservation/AllMembersCasePreserved/Code.cs @@ -0,0 +1,36 @@ +using System; +using System.Runtime.CompilerServices; + +[assembly: ScriptAssembly("test")] +[assembly: ScriptDefaultMemberCasePreservation(true)] + +namespace CasePreservationTests { + + public class Foo { + + public Foo(int i, int j) { + } + + public override string ToString() { + return "Foo"; + } + + public virtual int Sum(int i) { + return 0; + } + } + + public class Bar : Foo { + + public Bar(int i, int j, Foo f) : base(i, j) { + } + + public override int Sum() { + return base.Sum(1) + 1; + } + + public override string ToString() { + return base.ToString() + " -> Bar"; + } + } +} diff --git a/tests/TestCases/CasePreservation/DefaultCase/Baseline.txt b/tests/TestCases/CasePreservation/DefaultCase/Baseline.txt new file mode 100644 index 000000000..5796133d0 --- /dev/null +++ b/tests/TestCases/CasePreservation/DefaultCase/Baseline.txt @@ -0,0 +1,43 @@ +"use strict"; + +define('test', ['ss'], function(ss) { + var $global = this; + + // CasePreservationTests.Foo + + function Foo(i, j) { + } + var Foo$ = { + toString: function() { + return 'Foo'; + }, + sum: function(i) { + return 0; + } + }; + + + // CasePreservationTests.Bar + + function Bar(i, j, f) { + Foo.call(this, i, j); + } + var Bar$ = { + sum: function() { + return Foo.prototype.sum.call(this, 1) + 1; + }, + toString: function() { + return Foo.prototype.toString.call(this) + ' -> Bar'; + } + }; + + + var $exports = ss.module('test', null, + { + Foo: [ Foo, Foo$, null ], + Bar: [ Bar, Bar$, Foo ] + }); + + + return $exports; +}); diff --git a/tests/TestCases/CasePreservation/DefaultCase/Code.cs b/tests/TestCases/CasePreservation/DefaultCase/Code.cs new file mode 100644 index 000000000..138217634 --- /dev/null +++ b/tests/TestCases/CasePreservation/DefaultCase/Code.cs @@ -0,0 +1,35 @@ +using System; +using System.Runtime.CompilerServices; + +[assembly: ScriptAssembly("test")] + +namespace CasePreservationTests { + + public class Foo { + + public Foo(int i, int j) { + } + + public override string ToString() { + return "Foo"; + } + + public virtual int Sum(int i) { + return 0; + } + } + + public class Bar : Foo { + + public Bar(int i, int j, Foo f) : base(i, j) { + } + + public override int Sum() { + return base.Sum(1) + 1; + } + + public override string ToString() { + return base.ToString() + " -> Bar"; + } + } +} diff --git a/tests/TestCases/CasePreservation/NoMemberCasePreserved/Baseline.txt b/tests/TestCases/CasePreservation/NoMemberCasePreserved/Baseline.txt new file mode 100644 index 000000000..5796133d0 --- /dev/null +++ b/tests/TestCases/CasePreservation/NoMemberCasePreserved/Baseline.txt @@ -0,0 +1,43 @@ +"use strict"; + +define('test', ['ss'], function(ss) { + var $global = this; + + // CasePreservationTests.Foo + + function Foo(i, j) { + } + var Foo$ = { + toString: function() { + return 'Foo'; + }, + sum: function(i) { + return 0; + } + }; + + + // CasePreservationTests.Bar + + function Bar(i, j, f) { + Foo.call(this, i, j); + } + var Bar$ = { + sum: function() { + return Foo.prototype.sum.call(this, 1) + 1; + }, + toString: function() { + return Foo.prototype.toString.call(this) + ' -> Bar'; + } + }; + + + var $exports = ss.module('test', null, + { + Foo: [ Foo, Foo$, null ], + Bar: [ Bar, Bar$, Foo ] + }); + + + return $exports; +}); diff --git a/tests/TestCases/CasePreservation/NoMemberCasePreserved/Code.cs b/tests/TestCases/CasePreservation/NoMemberCasePreserved/Code.cs new file mode 100644 index 000000000..01a148279 --- /dev/null +++ b/tests/TestCases/CasePreservation/NoMemberCasePreserved/Code.cs @@ -0,0 +1,36 @@ +using System; +using System.Runtime.CompilerServices; + +[assembly: ScriptAssembly("test")] +[assembly: ScriptDefaultMemberCasePreservation(false)] + +namespace CasePreservationTests { + + public class Foo { + + public Foo(int i, int j) { + } + + public override string ToString() { + return "Foo"; + } + + public virtual int Sum(int i) { + return 0; + } + } + + public class Bar : Foo { + + public Bar(int i, int j, Foo f) : base(i, j) { + } + + public override int Sum() { + return base.Sum(1) + 1; + } + + public override string ToString() { + return base.ToString() + " -> Bar"; + } + } +} diff --git a/tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Baseline.txt b/tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Baseline.txt new file mode 100644 index 000000000..0adb92947 --- /dev/null +++ b/tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Baseline.txt @@ -0,0 +1,43 @@ +"use strict"; + +define('test', ['ss'], function(ss) { + var $global = this; + + // CasePreservationTests.Foo + + function Foo(i, j) { + } + var Foo$ = { + ToString: function() { + return 'Foo'; + }, + sum: function(i) { + return 0; + } + }; + + + // CasePreservationTests.Bar + + function Bar(i, j, f) { + Foo.call(this, i, j); + } + var Bar$ = { + Sum: function() { + return Foo.prototype.sum.call(this, 1) + 1; + }, + ToString: function() { + return Foo.prototype.ToString.call(this) + ' -> Bar'; + } + }; + + + var $exports = ss.module('test', null, + { + Foo: [ Foo, Foo$, null ], + Bar: [ Bar, Bar$, Foo ] + }); + + + return $exports; +}); diff --git a/tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Code.cs b/tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Code.cs new file mode 100644 index 000000000..4161a4ca9 --- /dev/null +++ b/tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Code.cs @@ -0,0 +1,37 @@ +using System; +using System.Runtime.CompilerServices; + +[assembly: ScriptAssembly("test")] +[assembly: ScriptDefaultMemberCasePreservation(true)] + +namespace CasePreservationTests { + + public class Foo { + + public Foo(int i, int j) { + } + + public override string ToString() { + return "Foo"; + } + + [ScriptName(PreserveCase=false)] + public virtual int Sum(int i) { + return 0; + } + } + + public class Bar : Foo { + + public Bar(int i, int j, Foo f) : base(i, j) { + } + + public override int Sum() { + return base.Sum(1) + 1; + } + + public override string ToString() { + return base.ToString() + " -> Bar"; + } + } +} diff --git a/tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Baseline.txt b/tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Baseline.txt new file mode 100644 index 000000000..2c5a29e3a --- /dev/null +++ b/tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Baseline.txt @@ -0,0 +1,43 @@ +"use strict"; + +define('test', ['ss'], function(ss) { + var $global = this; + + // CasePreservationTests.Foo + + function Foo(i, j) { + } + var Foo$ = { + toString: function() { + return 'Foo'; + }, + sum: function(i) { + return 0; + } + }; + + + // CasePreservationTests.Bar + + function Bar(i, j, f) { + Foo.call(this, i, j); + } + var Bar$ = { + Sum: function() { + return Foo.prototype.sum.call(this, 1) + 1; + }, + ToString: function() { + return Foo.prototype.toString.call(this) + ' -> Bar'; + } + }; + + + var $exports = ss.module('test', null, + { + Foo: [ Foo, Foo$, null ], + Bar: [ Bar, Bar$, Foo ] + }); + + + return $exports; +}); diff --git a/tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Code.cs b/tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Code.cs new file mode 100644 index 000000000..41ab29e9c --- /dev/null +++ b/tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Code.cs @@ -0,0 +1,37 @@ +using System; +using System.Runtime.CompilerServices; + +[assembly: ScriptAssembly("test")] +[assembly: ScriptDefaultMemberCasePreservation(true)] + +namespace CasePreservationTests { + + [ScriptName(PreserveCase=false)] + public class Foo { + + public Foo(int i, int j) { + } + + public override string ToString() { + return "Foo"; + } + + public virtual int Sum(int i) { + return 0; + } + } + + public class Bar : Foo { + + public Bar(int i, int j, Foo f) : base(i, j) { + } + + public override int Sum() { + return base.Sum(1) + 1; + } + + public override string ToString() { + return base.ToString() + " -> Bar"; + } + } +} diff --git a/tests/Tests.csproj b/tests/Tests.csproj index 9f4afb319..fa4900344 100644 --- a/tests/Tests.csproj +++ b/tests/Tests.csproj @@ -59,6 +59,7 @@ +