protected void AssertCorrect(string csharp, string expected, INamingConventionResolver namingConvention = null, IRuntimeLibrary runtimeLibrary = null, bool addSkeleton = true, bool referenceSystemCore = false) { CompileMethod(csharp, namingConvention: namingConvention ?? new MockNamingConventionResolver { GetPropertySemantics = p => { if (p.DeclaringType.Kind == TypeKind.Anonymous || new Regex("^F[0-9]*$").IsMatch(p.Name) || (p.DeclaringType.FullName == "System.Array" && p.Name == "Length")) return PropertyScriptSemantics.Field("$" + p.Name); else return PropertyScriptSemantics.GetAndSetMethods(MethodScriptSemantics.NormalMethod("get_$" + p.Name), MethodScriptSemantics.NormalMethod("set_$" + p.Name)); }, GetMethodSemantics = m => MethodScriptSemantics.NormalMethod("$" + m.Name), GetEventSemantics = e => EventScriptSemantics.AddAndRemoveMethods(MethodScriptSemantics.NormalMethod("add_$" + e.Name), MethodScriptSemantics.NormalMethod("remove_$" + e.Name)), }, runtimeLibrary: runtimeLibrary, addSkeleton: addSkeleton, referenceSystemCore: referenceSystemCore); string actual = OutputFormatter.Format(CompiledMethod, true); int begin = actual.IndexOf("// BEGIN"); if (begin > -1) { while (begin < (actual.Length - 1) && actual[begin - 1] != '\n') begin++; actual = actual.Substring(begin); } int end = actual.IndexOf("// END"); if (end >= 0) { while (end >= 0 && actual[end] != '\n') end--; actual = actual.Substring(0, end + 1); } Assert.That(actual.Replace("\r\n", "\n"), Is.EqualTo(expected.Replace("\r\n", "\n"))); }
protected void CompileMethod(string source, INamingConventionResolver namingConvention = null, IRuntimeLibrary runtimeLibrary = null, IErrorReporter errorReporter = null, string methodName = "M", bool addSkeleton = true, bool referenceSystemCore = false) { Compile(new[] { addSkeleton ? "using System; class C { " + source + "}" : source }, namingConvention, runtimeLibrary, errorReporter, (m, res, mc) => { if (m.Name == methodName) { Method = m; MethodCompiler = mc; CompiledMethod = res; } }, referenceSystemCore: referenceSystemCore); Assert.That(Method, Is.Not.Null, "Method " + methodName + " was not compiled"); }
protected void Compile(IEnumerable<string> sources, INamingConventionResolver namingConvention = null, IRuntimeLibrary runtimeLibrary = null, IErrorReporter errorReporter = null, Action<IMethod, JsFunctionDefinitionExpression, MethodCompiler> methodCompiled = null, IList<string> defineConstants = null, bool allowUnsupportedConstructs = true, bool referenceSystemCore = false) { var sourceFiles = sources.Select((s, i) => new MockSourceFile("File" + i + ".cs", s)).ToList(); bool defaultErrorHandling = false; if (errorReporter == null) { defaultErrorHandling = true; errorReporter = new MockErrorReporter(true); } var compiler = new Saltarelle.Compiler.Compiler.Compiler(namingConvention ?? new MockNamingConventionResolver(), runtimeLibrary ?? new MockRuntimeLibrary(), errorReporter) { AllowUnsupportedConstructs = allowUnsupportedConstructs }; if (methodCompiled != null) compiler.MethodCompiled += methodCompiled; var references = referenceSystemCore ? new[] { Common.Mscorlib, Common.Linq } : new[] { Common.Mscorlib }; var c = compiler.CreateCompilation(sourceFiles, references, defineConstants); CompiledTypes = compiler.Compile(c).AsReadOnly(); if (defaultErrorHandling) { ((MockErrorReporter)errorReporter).AllMessagesText.Should().BeEmpty("Compile should not generate errors"); } }
internal StatementCompiler(INamingConventionResolver namingConvention, IErrorReporter errorReporter, ICompilation compilation, CSharpAstResolver resolver, IDictionary<IVariable, VariableData> variables, IDictionary<LambdaResolveResult, NestedFunctionData> nestedFunctions, IRuntimeLibrary runtimeLibrary, string thisAlias, ISet<string> usedVariableNames, NestedFunctionContext nestedFunctionContext, IMethod methodBeingCompiled, ISet<string> definedSymbols, ExpressionCompiler expressionCompiler, SharedValue<int> nextLabelIndex, IVariable currentVariableForRethrow, IDictionary<object, string> currentGotoCaseMap) { _namingConvention = namingConvention; _errorReporter = errorReporter; _compilation = compilation; _resolver = resolver; _variables = variables; _nestedFunctions = nestedFunctions; _runtimeLibrary = runtimeLibrary; _thisAlias = thisAlias; _usedVariableNames = usedVariableNames; _nestedFunctionContext = nestedFunctionContext; _methodBeingCompiled = methodBeingCompiled; _definedSymbols = definedSymbols; _currentVariableForRethrow = currentVariableForRethrow; _currentGotoCaseMap = currentGotoCaseMap; _nextLabelIndex = nextLabelIndex ?? new SharedValue<int>(1); _expressionCompiler = expressionCompiler ?? new ExpressionCompiler(compilation, namingConvention, runtimeLibrary, errorReporter, variables, nestedFunctions, v => CreateTemporaryVariable(v, new DomRegion(_filename, _location, _location)), c => new StatementCompiler(_namingConvention, _errorReporter, _compilation, _resolver, _variables, _nestedFunctions, _runtimeLibrary, thisAlias, _usedVariableNames, c, _methodBeingCompiled, _definedSymbols), thisAlias, nestedFunctionContext, null, _methodBeingCompiled); _result = new List<JsStatement>(); }
protected void AssertCorrectForBulkOperators(string csharp, string expected, bool includeEqualsAndNotEquals, INamingConventionResolver namingConvention = null) { // Bulk operators are all except for division, shift right, coalesce and the logical operators. foreach (var op in new[] { "*", "%", "+", "-", "<<", "<", ">", "<=", ">=", "&", "^", "|" }) { var jsOp = (op == "==" || op == "!=" ? op + "=" : op); // Script should use strict equals (===) rather than normal equals (==) AssertCorrect(csharp.Replace("+", op), expected.Replace("+", jsOp), namingConvention); } if (includeEqualsAndNotEquals) { AssertCorrect(csharp.Replace("+", "=="), expected.Replace("+", "==="), namingConvention); AssertCorrect(csharp.Replace("+", "!="), expected.Replace("+", "!=="), namingConvention); } }
public StatementCompiler(INamingConventionResolver namingConvention, IErrorReporter errorReporter, ICompilation compilation, CSharpAstResolver resolver, IDictionary<IVariable, VariableData> variables, IDictionary<LambdaResolveResult, NestedFunctionData> nestedFunctions, IRuntimeLibrary runtimeLibrary, string thisAlias, ISet<string> usedVariableNames, NestedFunctionContext nestedFunctionContext, IMethod methodBeingCompiled, ISet<string> definedSymbols) : this(namingConvention, errorReporter, compilation, resolver, variables, nestedFunctions, runtimeLibrary, thisAlias, usedVariableNames, nestedFunctionContext, methodBeingCompiled, definedSymbols, null, null, null, null) { }
protected void Compile(string source, INamingConventionResolver namingConvention = null, IRuntimeLibrary runtimeLibrary = null, IErrorReporter errorReporter = null, bool useFirstConstructor = false) { Compile(new[] { source }, namingConvention, runtimeLibrary, errorReporter, (m, res, mc) => { if (m.IsConstructor && (m.Attributes.Any() || useFirstConstructor)) { Constructor = m; MethodCompiler = mc; CompiledConstructor = res; } }); Assert.That(Constructor, Is.Not.Null, "No constructors with attributes were compiled."); }
protected void AssertCorrectForBulkOperators(string csharp, string expected, INamingConventionResolver namingConvention = null, bool addSkeleton = true) { // Bulk operators are all except for division and shift right. foreach (var op in new[] { "+", "*", "%", "-", "<<", "&", "|", "^" }) { AssertCorrect(csharp.Replace("+", op), expected.Replace("+", op), namingConvention, addSkeleton: addSkeleton); } }
protected void AssertCorrect(string csharp, string expected, INamingConventionResolver namingConvention = null, bool useFirstConstructor = false) { Compile(csharp, namingConvention, useFirstConstructor: useFirstConstructor); string actual = OutputFormatter.Format(CompiledConstructor, allowIntermediates: true); Assert.That(actual.Replace("\r\n", "\n"), Is.EqualTo(expected.Replace("\r\n", "\n"))); }
public VariableGatherer(CSharpAstResolver resolver, INamingConventionResolver namingConvention, IErrorReporter errorReporter) { _resolver = resolver; _namingConvention = namingConvention; _errorReporter = errorReporter; }
protected void AssertCorrectForBoth(string csharp, string expected, INamingConventionResolver namingConvention = null) { AssertCorrect(csharp, expected, namingConvention); AssertCorrect(csharp.Replace("+", "-"), expected.Replace("+", "-"), namingConvention); }
private static void FindUsedUnusableTypes(IEnumerable<IType> types, INamingConventionResolver namingConvention, HashSet<ITypeDefinition> result) { foreach (var t in types) { if (t is ITypeDefinition) { if (namingConvention.GetTypeSemantics((ITypeDefinition)t).Type == TypeScriptSemantics.ImplType.NotUsableFromScript) result.Add((ITypeDefinition)t); } else if (t is ParameterizedType) { var pt = (ParameterizedType)t; FindUsedUnusableTypes(new[] { pt.GetDefinition() }.Concat(pt.TypeArguments), namingConvention, result); } } }
public static IEnumerable<ITypeDefinition> FindUsedUnusableTypes(IEnumerable<IType> types, INamingConventionResolver namingConvention) { var s = new HashSet<ITypeDefinition>(); FindUsedUnusableTypes(types, namingConvention, s); return s; }
public Compiler(INamingConventionResolver namingConvention, IRuntimeLibrary runtimeLibrary, IErrorReporter errorReporter) { _namingConvention = namingConvention; _errorReporter = errorReporter; _runtimeLibrary = runtimeLibrary; }