protected void AssertCompilerReturnsMessage( string input, CompilerMessageId messageId, CompilerMessageType messageType, string[] messageParameters) { // Arrange var compiler = new ThriftCompiler(); var parserInput = ParserInput.FromString(input); // Act var result = compiler.Compile(parserInput.GetStream()); // Assert var message = result.Messages.FirstOrDefault( m => m.MessageType == messageType && m.MessageId == messageId); Assert.True(message != null, $"No {messageType.ToString().ToLower()} messages were returned from the compiler"); if (parserInput.LineNumber != null) { Assert.Equal(parserInput.LineNumber, message.LineNumber); Assert.Equal(parserInput.StartPosition, message.StartPosition); Assert.Equal(parserInput.EndPosition, message.EndPosition); } if (messageParameters?.Length > 0) { var expectedMessage = string.Format( CompilerMessages.Get(messageId), messageParameters); Assert.Equal(expectedMessage, message.Message); } }
private void ErrorsOccurred(CompilerMessages errors) { if (OnErrors != null) { OnErrors(this, errors); } }
public void Open() { if (_shouldOpen && (_cursor == null)) { if (_plan == null) { try { _cursor = _process.OpenCursor(_expression, _params); } catch (Exception exception) { CompilerMessages messages = new CompilerMessages(); messages.Add(exception); ErrorsOccurred(messages); throw exception; } _plan = _cursor.Plan; _tableVar = _plan.TableVar; ErrorsOccurred(_plan.Messages); } else { _cursor = _plan.Open(_params); } } }
public static AssemblyDefinition Build(IWeaverLogger logger) { AssemblyDefinition assembly = null; var assemblyBuilder = new AssemblyBuilder(Path.Combine(OutputDirectory, OutputFile), SourceFiles.ToArray()) { referencesOptions = ReferencesOptions.UseEngineModules }; if (AllowUnsafe) { assemblyBuilder.compilerOptions.AllowUnsafeCode = true; } assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages) { CompilerMessages.AddRange(compilerMessages); foreach (CompilerMessage cm in compilerMessages) { if (cm.type == CompilerMessageType.Error) { Debug.Log($"Error At: {cm.file}:{ cm.line} -- {cm.message}"); CompilerErrors = true; } } Debug.LogWarning($"Test Assembler errors: {CompilerErrors} for {OutputFile}"); // assembly builder does not call ILPostProcessor (WTF Unity?), so we must invoke it ourselves. var compiledAssembly = new CompiledAssembly(assemblyPath) { Defines = assemblyBuilder.defaultDefines, References = assemblyBuilder.defaultReferences }; var weaver = new Weaver(logger); assembly = weaver.Weave(compiledAssembly); }; // Start build of assembly if (!assemblyBuilder.Build()) { Debug.LogErrorFormat("Failed to start build of assembly {0}", assemblyBuilder.assemblyPath); return(assembly); } while (assemblyBuilder.status != AssemblyBuilderStatus.Finished) { System.Threading.Thread.Sleep(10); } return(assembly); }
public void GetMessage_ForAllMessageIds_ReturnsMessage(CompilerMessageId messageId) { // Arrange var messageKey = CompilerMessages.FormatMessageId(messageId); var expectedMessage = this.resourceManager.GetString(messageKey); // Act var actualMessage = CompilerMessages.Get(messageId); // Assert Assert.True(!string.IsNullOrEmpty(expectedMessage), $"Compiler message missing for {messageKey}"); Assert.Equal(expectedMessage, actualMessage); }
/// <returns> True if no errors. Continue processing... </returns> public static bool ConvertCompilerErrors(CompilerMessages messages, ErrorList errors) { bool anyErrors = false; CompilerException compilerException; foreach (Exception exception in messages) { compilerException = exception as CompilerException; anyErrors = anyErrors || (compilerException == null) || (compilerException.ErrorLevel != CompilerErrorLevel.Warning); errors.Add(exception); } return(!anyErrors); }
/// <summary> /// Builds and Weaves an Assembly with references to unity engine and other asmdefs. /// <para> /// NOTE: Does not write the weaved assemble to disk /// </para> /// </summary> public AssemblyDefinition Build(IWeaverLogger logger) { AssemblyDefinition assembly = null; // This will compile scripts with the same references as files in the asset folder. // This means that the dll will get references to all asmdef just as if it was the default "Assembly-CSharp.dll" var assemblyBuilder = new AssemblyBuilder(ProjectPathFile, sourceFiles.ToArray()) { referencesOptions = ReferencesOptions.UseEngineModules }; assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages) { #if !UNITY_2020_2_OR_NEWER CompilerMessages.AddRange(compilerMessages); foreach (CompilerMessage cm in compilerMessages) { if (cm.type == CompilerMessageType.Error) { Debug.LogErrorFormat("{0}:{1} -- {2}", cm.file, cm.line, cm.message); CompilerErrors = true; } } #endif // assembly builder does not call ILPostProcessor (WTF Unity?), so we must invoke it ourselves. var compiledAssembly = new CompiledAssembly(assemblyPath) { Defines = assemblyBuilder.defaultDefines, References = assemblyBuilder.defaultReferences }; var weaver = new Weaver(logger); assembly = weaver.Weave(compiledAssembly); }; // Start build of assembly if (!assemblyBuilder.Build()) { Debug.LogErrorFormat("Failed to start build of assembly {0}", assemblyBuilder.assemblyPath); return(assembly); } while (assemblyBuilder.status != AssemblyBuilderStatus.Finished) { System.Threading.Thread.Sleep(10); } return(assembly); }
// clear all settings except for referenced assemblies (which are cleared with ClearReferences) public static void Clear() { if (DeleteOutputOnClear) { DeleteOutput(); } CompilerErrors = false; OutputFile = ""; SourceFiles.Clear(); CompilerMessages.Clear(); AllowUnsafe = false; DeleteOutputOnClear = false; }
static void BuildAssembly(bool wait) { AssemblyBuilder assemblyBuilder = new AssemblyBuilder(OutputDirectory + OutputFile, SourceFiles.ToArray()); assemblyBuilder.additionalReferences = ReferenceAssemblies.ToArray(); if (AllowUnsafe) { assemblyBuilder.compilerOptions.AllowUnsafeCode = true; } assemblyBuilder.buildStarted += delegate(string assemblyPath) { //Debug.LogFormat("Assembly build started for {0}", assemblyPath); }; assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages) { CompilerMessages.AddRange(compilerMessages); foreach (CompilerMessage cm in compilerMessages) { if (cm.type == CompilerMessageType.Warning) { //Debug.LogWarningFormat("{0}:{1} -- {2}", cm.file, cm.line, cm.message); } else if (cm.type == CompilerMessageType.Error) { Debug.LogErrorFormat("{0}:{1} -- {2}", cm.file, cm.line, cm.message); CompilerErrors = true; } } }; // Start build of assembly if (!assemblyBuilder.Build()) { Debug.LogErrorFormat("Failed to start build of assembly {0}", assemblyBuilder.assemblyPath); return; } if (wait) { while (assemblyBuilder.status != AssemblyBuilderStatus.Finished) { System.Threading.Thread.Sleep(10); } } }
/// <summary> /// Creates a warning message, specifying the tokens to highlight. /// </summary> /// <param name="messageId">The compiler message Id.</param> /// <param name="startToken"> /// The starting token that the warning should be placed against. /// </param> /// <param name="endToken"> /// The end token that the warning should be placed against. /// </param> /// <param name="messageParameters"> /// Any parameters to include when formatting the compiler message. /// </param> /// <returns>The warning message.</returns> public static CompilationMessage CreateWarning( CompilerMessageId messageId, IToken startToken, IToken endToken, string[] messageParameters) { string formattedMessage = string.Format( CompilerMessages.Get(messageId), messageParameters); return(new CompilationMessage( messageId, CompilerMessageType.Warning, startToken.Line, startToken.Column + 1, endToken.Column + endToken.Text.Length, formattedMessage)); }
private void buildFinished(string assemblyPath, CompilerMessage[] compilerMessages) { Log($"buildFinished for {OutputFile}"); // in unity2020, ILPP runs automatically. but in unity2021 it does not #if !UNITY_2020_2_OR_NEWER || UNITY_2021_3_OR_NEWER CompilerMessages.AddRange(compilerMessages); foreach (CompilerMessage m in compilerMessages) { if (m.type == CompilerMessageType.Error) { // first error if (!CompilerErrors) { LogWarning($"Batch failed!!!"); } CompilerErrors = true; LogWarning($"{m.file}:{m.line} -- {m.message}"); } } // we can't run weaver if there are compile errors if (CompilerErrors) { return; } #endif // call weaver on result var compiledAssembly = new CompiledAssembly(assemblyPath, builder); Log($"Starting weaver on {OutputFile}"); var weaver = new Mirage.Weaver.Weaver(logger); builtAssembly = weaver.Weave(compiledAssembly); Log($"Finished weaver on {OutputFile}"); // NOTE: we need to write to check for ArgumentException from writing TryWriteAssembly(builtAssembly); }
protected void AssertCompilerReturnsMessage( string input, CompilerMessageId messageId, CompilerMessageType messageType, string[] messageParameters) { // Arrange var compiler = new ThriftCompiler(); var parserInput = ParserInput.FromString(input); // Act var result = compiler.Compile(parserInput.GetStream()); // Assert var message = result.Messages.FirstOrDefault( m => m.MessageType == messageType && m.MessageId == messageId); Assert.True(message != null, $"No {messageType.ToString().ToLower()} messages were returned from the compiler"); // Although we know that message cannot be null because of the assert on // the previous line, check for null here because the lgtm check isn't // smart enough to realise that if (message != null) { if (parserInput.LineNumber != null) { Assert.Equal(parserInput.LineNumber, message.LineNumber); Assert.Equal(parserInput.StartPosition, message.StartPosition); Assert.Equal(parserInput.EndPosition, message.EndPosition); } if (messageParameters?.Length > 0) { var expectedMessage = string.Format( CompilerMessages.Get(messageId), messageParameters); Assert.Equal(expectedMessage, message.Message); } } }
public void When_CompilationHasMessages_OutputsMessages() { // Arrange var inputFile = this.fileCreator.CreateTempFile(); var outputDirectory = this.fileCreator.GetTempDirectory(); this.SetupCompilationWithMessages( new CompilationMessage(CompilerMessageId.EnumMustHaveAName, CompilerMessageType.Error, 1, 1, 4, "Message 1"), new CompilationMessage(CompilerMessageId.EnumMemberMustHaveAName, CompilerMessageType.Error, 2, 4, 8, "Message 2")); this.SetupCreateThriftFile(inputFile); // Act Program.Main(inputFile, outputDirectory, this.console); // Assert var enumMustHaveName = CompilerMessages.FormatMessageId(CompilerMessageId.EnumMustHaveAName); var enumMemberMustHaveName = CompilerMessages.FormatMessageId(CompilerMessageId.EnumMemberMustHaveAName); this.console.Out.Received().Write( $"{inputFile.Name}(1,1-4): Error {enumMustHaveName}: Message 1 [{inputFile.FullName}]{Environment.NewLine}"); this.console.Out.Received().Write( $"{inputFile.Name}(2,4-8): Error {enumMemberMustHaveName}: Message 2 [{inputFile.FullName}]{Environment.NewLine}"); }
public static void Build() { var assemblyBuilder = new AssemblyBuilder(Path.Combine(OutputDirectory, OutputFile), SourceFiles.ToArray()) { referencesOptions = ReferencesOptions.UseEngineModules }; if (AllowUnsafe) { assemblyBuilder.compilerOptions.AllowUnsafeCode = true; } assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages) { CompilerMessages.AddRange(compilerMessages); foreach (CompilerMessage cm in compilerMessages) { if (cm.type == CompilerMessageType.Error) { Debug.LogErrorFormat("{0}:{1} -- {2}", cm.file, cm.line, cm.message); CompilerErrors = true; } } }; // Start build of assembly if (!assemblyBuilder.Build()) { Debug.LogErrorFormat("Failed to start build of assembly {0}", assemblyBuilder.assemblyPath); return; } while (assemblyBuilder.status != AssemblyBuilderStatus.Finished) { System.Threading.Thread.Sleep(10); } }
protected void CursorOnErrors(DAECursor cursor, CompilerMessages messages) { ReportErrors(messages); }
public static void Build(Action <string> OnWarning, Action <string> OnError) { AssemblyBuilder assemblyBuilder = new AssemblyBuilder(Path.Combine(OutputDirectory, OutputFile), SourceFiles.ToArray()) { // "The type 'MonoBehaviour' is defined in an assembly that is not referenced" referencesOptions = ReferencesOptions.UseEngineModules }; if (AllowUnsafe) { assemblyBuilder.compilerOptions.AllowUnsafeCode = true; } #if UNITY_2020_3_OR_NEWER // Unity automatically invokes ILPostProcessor after // AssemblyBuilder.Build() (on windows at least. not on mac). // => .buildFinished() below CompilerMessages would already contain // the weaver messages, failing tests. // => SyncVarTests->SyncVarSyncList fails too if ILPP was // already applied by Unity, and we apply it again. // // we need to not run ILPP for WeaverTests assemblies here. // -> we can't set member variables because Unity creates a new // ILPP instance internally and invokes it // -> define is passed through ILPP though, and avoids static state. assemblyBuilder.additionalDefines = new [] { ILPostProcessorHook.IgnoreDefine }; #endif assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages) { // CompilerMessages from compiling the original test assembly. // note that we can see weaver messages here if Unity runs // ILPostProcessor after AssemblyBuilder.Build(). // => that's why we pass the ignore define above. CompilerMessages.AddRange(compilerMessages); foreach (CompilerMessage cm in compilerMessages) { if (cm.type == CompilerMessageType.Error) { Debug.LogError($"{cm.file}:{cm.line} -- {cm.message}"); CompilerErrors = true; } } #if UNITY_2020_3_OR_NEWER // on 2018/2019, CompilationFinishedHook weaves after building. // on 2020, ILPostProcessor weaves after building. // on windows, it runs after AssemblyBuilder.Build() // on mac, it does not run after AssemblyBuidler.Build() // => run it manually in all cases // => this way we can feed result.Logs to test results too // NOTE: we could simply call Weaver.Weave() here. // but let's make all tests run through ILPP. // just like regular projects would. // helps catch issues early. // copy references from assemblyBuilder's references List <string> references = new List <string>(); if (assemblyBuilder.defaultReferences != null) { references.AddRange(assemblyBuilder.defaultReferences); } if (assemblyBuilder.additionalReferences != null) { references.AddRange(assemblyBuilder.additionalReferences); } // invoke ILPostProcessor with an assembly from file. // NOTE: code for creating and invoking the ILPostProcessor has // to be in Weaver.dll where 'CompilationPipeline' is // available due to name being of form 'Unity.*.CodeGen'. // => we can't change tests to that Unity.*.CodeGen // because some tests need to be weaved, but ILPP isn't // ran on Unity.*.CodeGen assemblies itself. ILPostProcessorFromFile.ILPostProcessFile(assemblyPath, references.ToArray(), OnWarning, OnError); #endif }; // Start build of assembly if (!assemblyBuilder.Build()) { Debug.LogError($"Failed to start build of assembly {assemblyBuilder.assemblyPath}"); return; } while (assemblyBuilder.status != AssemblyBuilderStatus.Finished) { Thread.Sleep(10); } }