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);
}
}
