From 0b2d2770ac4c94b4ae14e589f090e33c215df4b7 Mon Sep 17 00:00:00 2001 From: inaseer Date: Sun, 21 Sep 2014 20:27:42 -0700 Subject: [PATCH] Add abiltiy to specify the default member case preservation to be used throughout an assembly. It is always assumed to be false without this feature. Also add the ability to specify the case preservation of all members of a type through ScriptName.PreserveCase property on the type. --- src/Core/Compiler/Compiler/MetadataBuilder.cs | 133 +++++++++++------- src/Core/Compiler/Importer/MetadataHelpers.cs | 16 ++- .../Compiler/Importer/MetadataImporter.cs | 29 ++-- .../ScriptModel/Symbols/TypeSymbol.cs | 15 ++ src/Core/CoreLib/ScriptMetadata.cs | 19 +++ tests/CasePreservationTests.cs | 50 +++++++ .../AllMembersCasePreserved/Baseline.txt | 43 ++++++ .../AllMembersCasePreserved/Code.cs | 36 +++++ .../CasePreservation/DefaultCase/Baseline.txt | 43 ++++++ .../CasePreservation/DefaultCase/Code.cs | 35 +++++ .../NoMemberCasePreserved/Baseline.txt | 43 ++++++ .../NoMemberCasePreserved/Code.cs | 36 +++++ .../OneMemberCaseNotPreserved/Baseline.txt | 43 ++++++ .../OneMemberCaseNotPreserved/Code.cs | 37 +++++ .../Baseline.txt | 43 ++++++ .../OneTypesMembersCaseNotPreserved/Code.cs | 37 +++++ tests/Tests.csproj | 1 + 17 files changed, 598 insertions(+), 61 deletions(-) create mode 100644 tests/CasePreservationTests.cs create mode 100644 tests/TestCases/CasePreservation/AllMembersCasePreserved/Baseline.txt create mode 100644 tests/TestCases/CasePreservation/AllMembersCasePreserved/Code.cs create mode 100644 tests/TestCases/CasePreservation/DefaultCase/Baseline.txt create mode 100644 tests/TestCases/CasePreservation/DefaultCase/Code.cs create mode 100644 tests/TestCases/CasePreservation/NoMemberCasePreserved/Baseline.txt create mode 100644 tests/TestCases/CasePreservation/NoMemberCasePreserved/Code.cs create mode 100644 tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Baseline.txt create mode 100644 tests/TestCases/CasePreservation/OneMemberCaseNotPreserved/Code.cs create mode 100644 tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Baseline.txt create mode 100644 tests/TestCases/CasePreservation/OneTypesMembersCaseNotPreserved/Code.cs 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 @@ +