com.wallstop-studios.dxmessaging 2.2.0 → 3.1.0

package/Editor/Analyzers/BaseCallIlInspector.cs

@@ -0,0 +1,277 @@
+// The Unity Editor assembly that hosts this file does not enable nullable annotations; the
+// dotnet-test project that compiles a linked copy DOES (`<Nullable>enable</Nullable>`). Pin the
+// nullable state per-file so behavior is identical in both compilation contexts.
+#nullable disable
+namespace DxMessaging.Editor.Analyzers
+{
+    using System;
+    using System.Reflection;
+    using System.Reflection.Emit;
+
+    /// <summary>
+    /// Pure (Unity-API-free) IL inspector that decides whether a given <see cref="MethodInfo"/>'s
+    /// IL body invokes a parent's same-named method (i.e. the IL emit shape of <c>base.X()</c>).
+    /// Extracted from <c>BaseCallTypeScanner</c> so the dotnet-test project can cover the byte
+    /// walker without depending on Unity APIs.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// <b>Why does this exist?</b> The console-scrape harvester is non-deterministic across Unity
+    /// 2021 cache hits (Unity skips routing analyzer warnings to <c>LogEntries</c> /
+    /// <c>CompilerMessage[]</c> on incremental compiles where Bee/csc reused a cached output).
+    /// IL reflection over the loaded assemblies in the AppDomain is deterministic -- the bytes do
+    /// not depend on Unity's compile-pipeline state. <see cref="BaseCallTypeScanner"/> uses this
+    /// helper to classify every loaded <c>MessageAwareComponent</c> subclass on every domain
+    /// reload.
+    /// </para>
+    /// <para>
+    /// <b>Proper OpCodes-table walker.</b> The walker decodes every CIL instruction by looking up
+    /// its <see cref="OpCode"/> in the static tables built from <see cref="OpCodes"/> reflection
+    /// (single-byte and two-byte 0xFE-prefix forms) and steps the operand-size that the opcode
+    /// declares (<see cref="OpCode.OperandType"/>). Misalignment past multi-byte-operand opcodes
+    /// (<c>switch</c> jump tables, <c>ldstr</c> 4-byte tokens, 8-byte literal constants, etc.) is
+    /// therefore impossible -- the walker either consumes every byte correctly or stops at the
+    /// first unrecognised opcode. Phantom DXMSG006 from a misread <c>0x28</c> inside a wider
+    /// operand is no longer a failure mode.
+    /// </para>
+    /// <para>
+    /// <b>Defensive bias.</b> When we cannot reason at all (null method, empty name, inaccessible
+    /// IL body, <c>GetMethodBody()</c> returns null on abstract / P/Invoke / IL2CPP-stripped
+    /// targets, or any reflection exception), the inspector returns <c>true</c>
+    /// ("assume clean -- calls base") so the scanner never invents a phantom warning. The
+    /// compile-time analyzer is the authoritative source for CI builds (DXMSG006/007/009/010 via
+    /// full Roslyn semantic-model precision); the IL scanner exists only to make the editor
+    /// overlay light up at edit-time, where a missed warning is far worse than a phantom one.
+    /// </para>
+    /// </remarks>
+    public static class BaseCallIlInspector
+    {
+        // CIL opcode tables, indexed by the low byte of OpCode.Value. Built once by reflecting over
+        // System.Reflection.Emit.OpCodes; every public static OpCode field there represents a
+        // canonical CIL instruction. The two-byte form of the table is used when a 0xFE prefix is
+        // observed in the IL stream; otherwise we use the single-byte form. Because CIL specifies
+        // exactly two prefix bytes (single-byte = direct, two-byte = 0xFE prefix), this division
+        // covers every defined opcode.
+        private static readonly OpCode[] s_singleByteOps = BuildOpCodeTable(twoByte: false);
+        private static readonly OpCode[] s_twoByteOps = BuildOpCodeTable(twoByte: true);
+
+        private static OpCode[] BuildOpCodeTable(bool twoByte)
+        {
+            OpCode[] table = new OpCode[256];
+            foreach (
+                FieldInfo field in typeof(OpCodes).GetFields(
+                    BindingFlags.Public | BindingFlags.Static
+                )
+            )
+            {
+                if (field.GetValue(null) is not OpCode op)
+                {
+                    continue;
+                }
+                ushort value = (ushort)op.Value;
+                bool isTwoByte = (value & 0xFF00) == 0xFE00;
+                bool isSingleByte = (value & 0xFF00) == 0;
+                if (twoByte && isTwoByte)
+                {
+                    table[value & 0xFF] = op;
+                }
+                else if (!twoByte && isSingleByte)
+                {
+                    table[value & 0xFF] = op;
+                }
+            }
+            return table;
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> if <paramref name="method"/>'s IL body contains a
+        /// <c>call</c>/<c>callvirt</c> to a parent type's same-named method. Defensive:
+        /// returns <c>true</c> (assume-clean) if the IL body is null/inaccessible to avoid
+        /// false-positive warnings on platforms or methods where reflection on bodies is
+        /// restricted (abstract methods, P/Invoke, IL2CPP-stripped bodies, etc.).
+        /// </summary>
+        /// <param name="method">The override on the descendant type whose IL we wish to inspect.</param>
+        /// <param name="methodName">The expected base method name (e.g. <c>"OnEnable"</c>).</param>
+        /// <returns>
+        /// <c>true</c> if the IL contains a base-call shape, OR the IL was inaccessible (safe
+        /// default -- assume clean). <c>false</c> only when IL was readable AND no call/callvirt
+        /// targeting a parent same-named method was found.
+        /// </returns>
+        public static bool MethodIlContainsBaseCall(MethodInfo method, string methodName)
+        {
+            if (method == null || string.IsNullOrEmpty(methodName))
+            {
+                // Defensive: treat as clean when we don't have enough information to reason. This
+                // ensures the scanner never emits a phantom warning on a degenerate input.
+                return true;
+            }
+
+            try
+            {
+                MethodBody body = method.GetMethodBody();
+                if (body == null)
+                {
+                    // Abstract / extern / runtime-implemented / IL2CPP-stripped; cannot inspect.
+                    return true;
+                }
+
+                byte[] il = body.GetILAsByteArray();
+                if (il == null || il.Length == 0)
+                {
+                    return true;
+                }
+
+                Module module = method.Module;
+                Type[] genericTypeArgs =
+                    method.DeclaringType?.IsGenericType == true
+                        ? method.DeclaringType.GetGenericArguments()
+                        : null;
+                Type[] genericMethodArgs = method.IsGenericMethod
+                    ? method.GetGenericArguments()
+                    : null;
+
+                int i = 0;
+                while (i < il.Length)
+                {
+                    OpCode op;
+                    if (il[i] == 0xFE)
+                    {
+                        // Two-byte (0xFE-prefixed) opcode. Without a following byte we cannot
+                        // decode the instruction; bail out conservatively. Truncated IL is not a
+                        // shape Roslyn ever emits, so reaching this path means we mis-stepped and
+                        // the safest answer is the assume-clean default.
+                        if (i + 1 >= il.Length)
+                        {
+                            return true;
+                        }
+                        op = s_twoByteOps[il[i + 1]];
+                        i += 2;
+                    }
+                    else
+                    {
+                        op = s_singleByteOps[il[i]];
+                        i += 1;
+                    }
+
+                    // Unrecognised opcode (zero-initialised slot in the table); abandon the walk
+                    // rather than risk the rest of the stream getting misread. Returning the
+                    // assume-clean default keeps the scanner from inventing a phantom warning.
+                    if (op.Size == 0)
+                    {
+                        return true;
+                    }
+
+                    if (op == OpCodes.Call || op == OpCodes.Callvirt)
+                    {
+                        if (i + 4 > il.Length)
+                        {
+                            return true;
+                        }
+                        int token = BitConverter.ToInt32(il, i);
+                        try
+                        {
+                            MethodBase target = module.ResolveMethod(
+                                token,
+                                genericTypeArgs,
+                                genericMethodArgs
+                            );
+                            if (
+                                target != null
+                                && string.Equals(target.Name, methodName, StringComparison.Ordinal)
+                            )
+                            {
+                                Type declaring = method.DeclaringType;
+                                Type resolved = target.DeclaringType;
+                                // Guard against false-positives: the resolved method must live on a
+                                // STRICT base type of the declaring class (not the declaring class
+                                // itself, not a sibling, not a generic-arg shadow). IsAssignableFrom
+                                // checks "is `declaring` assignable TO `resolved`"; i.e. is
+                                // `resolved` an ancestor of `declaring`.
+                                if (
+                                    declaring != null
+                                    && resolved != null
+                                    && declaring != resolved
+                                    && resolved.IsAssignableFrom(declaring)
+                                )
+                                {
+                                    return true;
+                                }
+                            }
+                        }
+                        catch
+                        {
+                            // ResolveMethod throws on tokens that don't bind in our generic-arg
+                            // context (e.g. a MemberRef into a closed generic we can't resolve).
+                            // The OpCodes-table walker means we can no longer land on a misaligned
+                            // 0x28 inside a wider operand, so this catch only protects against
+                            // legitimate-but-unbindable tokens; we swallow and continue scanning.
+                        }
+                        i += 4;
+                        continue;
+                    }
+
+                    // Step over the operand based on the opcode's declared operand type. Every
+                    // CIL operand size is decided by OperandType, which is exactly why the table
+                    // walker is misalignment-proof.
+                    i += GetOperandSize(op, il, i);
+                }
+                return false;
+            }
+            catch
+            {
+                // Any reflection failure → assume clean. We never want the scanner itself to
+                // become the source of a phantom warning.
+                return true;
+            }
+        }
+
+        // Returns the number of operand bytes that follow an opcode of the given OperandType,
+        // given the operand-start offset (needed for InlineSwitch's variable-length jump table).
+        private static int GetOperandSize(OpCode op, byte[] il, int operandStart)
+        {
+            switch (op.OperandType)
+            {
+                case OperandType.InlineNone:
+                    return 0;
+                case OperandType.ShortInlineBrTarget:
+                case OperandType.ShortInlineI:
+                case OperandType.ShortInlineVar:
+                    return 1;
+                case OperandType.InlineVar:
+                    return 2;
+                case OperandType.InlineBrTarget:
+                case OperandType.InlineField:
+                case OperandType.InlineI:
+                case OperandType.InlineMethod:
+                case OperandType.InlineSig:
+                case OperandType.InlineString:
+                case OperandType.InlineTok:
+                case OperandType.InlineType:
+                case OperandType.ShortInlineR:
+                    return 4;
+                case OperandType.InlineI8:
+                case OperandType.InlineR:
+                    return 8;
+                case OperandType.InlineSwitch:
+                    // 4-byte case count, then N × 4-byte branch targets. Truncated stream → bail
+                    // by consuming the rest defensively (the outer loop's bounds check then ends
+                    // the walk).
+                    if (operandStart + 4 > il.Length)
+                    {
+                        return il.Length - operandStart;
+                    }
+                    int caseCount = BitConverter.ToInt32(il, operandStart);
+                    if (caseCount < 0)
+                    {
+                        // Negative case-count is malformed IL; bail conservatively.
+                        return il.Length - operandStart;
+                    }
+                    return 4 + caseCount * 4;
+                default:
+                    // Unknown OperandType; bail conservatively by consuming the rest of the
+                    // stream so the outer loop terminates without misaligning further.
+                    return il.Length - operandStart;
+            }
+        }
+    }
+}

package/Editor/Analyzers/BaseCallIlInspector.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f713afea6aef44cab4d711a4f2d17d6e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/Editor/Analyzers/BaseCallLogMessageParser.cs

@@ -0,0 +1,295 @@
+// The Unity Editor assembly that hosts this file does not enable nullable annotations; the
+// dotnet-test project that compiles a linked copy DOES (`<Nullable>enable</Nullable>`). Pin the
+// nullable state per-file so behavior is identical in both compilation contexts.
+#nullable disable
+namespace DxMessaging.Editor.Analyzers
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Text.RegularExpressions;
+
+    /// <summary>
+    /// Single parsed diagnostic line emitted by the <c>MessageAwareComponentBaseCallAnalyzer</c>.
+    /// </summary>
+    /// <remarks>
+    /// Empty <see cref="MethodName"/> is the documented sentinel for DXMSG008 (which carries no
+    /// method name in its message format). Empty <see cref="FilePath"/> / zero <see cref="Line"/>
+    /// indicate the bare (Unity-prefix-less) form of the message.
+    /// </remarks>
+    public readonly struct ParsedEntry
+    {
+        public string DiagnosticId { get; }
+
+        public string TypeFullName { get; }
+
+        public string MethodName { get; }
+
+        public string FilePath { get; }
+
+        public int Line { get; }
+
+        public ParsedEntry(
+            string diagnosticId,
+            string typeFullName,
+            string methodName,
+            string filePath,
+            int line
+        )
+        {
+            DiagnosticId = diagnosticId;
+            TypeFullName = typeFullName;
+            MethodName = methodName;
+            FilePath = filePath;
+            Line = line;
+        }
+    }
+
+    /// <summary>
+    /// Per-type aggregate produced by <see cref="BaseCallLogMessageParser.Aggregate"/>.
+    /// </summary>
+    /// <remarks>
+    /// <see cref="MissingBaseFor"/> is deduplicated and stored in deterministic ordinal-sorted order
+    /// via <see cref="SortedSet{T}"/>. <see cref="DiagnosticIds"/> uses ordinal comparison.
+    /// <see cref="FilePath"/> / <see cref="Line"/> hold the FIRST seen non-empty values so the
+    /// inspector overlay's "Open Script" jump remains stable across repeated parses.
+    /// </remarks>
+    public sealed class ParsedTypeReport
+    {
+        public string TypeFullName { get; set; }
+
+        public SortedSet<string> MissingBaseFor { get; } = new(StringComparer.Ordinal);
+
+        public HashSet<string> DiagnosticIds { get; } = new(StringComparer.Ordinal);
+
+        public string FilePath { get; set; }
+
+        public int Line { get; set; }
+    }
+
+    /// <summary>
+    /// Pure parser for the DXMSG006/DXMSG007/DXMSG008/DXMSG009/DXMSG010 console-log lines emitted
+    /// by the <c>MessageAwareComponentBaseCallAnalyzer</c>.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class lives in the Editor assembly so the harvester can call it directly without
+    /// referencing the Roslyn-analyzer DLL (Unity excludes <c>RoslynAnalyzer</c>-labelled
+    /// assemblies from asmdef compile-time references).
+    /// </para>
+    /// <para>
+    /// The analyzer-tests project compiles its own copy of this file via a
+    /// <c>&lt;Compile Include="...\BaseCallLogMessageParser.cs" Link="..." /&gt;</c> so the
+    /// existing dotnet-test coverage continues to run.
+    /// </para>
+    /// <para>
+    /// The regexes are pinned to the analyzer's verbatim message-format strings. Whenever those
+    /// formats change, both this parser AND <c>BaseCallLogMessageParserTests</c> must be updated
+    /// in lockstep.
+    /// </para>
+    /// </remarks>
+    public static class BaseCallLogMessageParser
+    {
+        // Roslyn / Unity-style location prefix:  path(line,col): warning DXMSG006:
+        // We don't anchor to the diagnostic id here beyond the leading "DXMSG"; that lets the
+        // same prefix regex serve all five diagnostics (DXMSG006/007/008/009/010). The trailing
+        // `: ` is consumed so the diagnostic-specific regexes only see the message body.
+        private const RegexOptions SharedOptions =
+            RegexOptions.Compiled | RegexOptions.CultureInvariant;
+
+        private static readonly Regex PrefixRegex = new(
+            @"^(?<path>[^()\r\n]+?)\((?<line>\d+),(?<col>\d+)\)\s*:\s*(?:warning|error|info|hidden|message)\s+DXMSG0(?:0[6789]|10)\s*:\s*",
+            SharedOptions
+        );
+
+        // DXMSG006 format:
+        //   '{type}' overrides MessageAwareComponent.{method} but does not call base.{method}();
+        //   the messaging system may not function correctly on this component.
+        // The type name is captured from the first single-quoted token; the method from the first
+        // `MessageAwareComponent.{method}` occurrence (the format string repeats `{method}`).
+        // Body regexes anchor to the start of the body (^) so a Debug.Log payload that *contains*
+        // the analyzer's wording mid-string is not surfaced as a real DXMSG006/007/008. The prefix
+        // (when present) is stripped before this match, so ^ here is the start of the message body.
+        private static readonly Regex Dxmsg006Regex = new(
+            @"^'(?<type>[^']+)'\s+overrides\s+MessageAwareComponent\.(?<method>[A-Za-z_][A-Za-z0-9_]*)\s+but\s+does\s+not\s+call\s+base\.[A-Za-z_][A-Za-z0-9_]*\(\)\s*;\s*the\s+messaging\s+system\s+may\s+not\s+function\s+correctly\s+on\s+this\s+component\.",
+            SharedOptions
+        );
+
+        // DXMSG007 format:
+        //   '{type}' hides MessageAwareComponent.{method} with 'new'; replace with 'override' and
+        //   call base.{method}() so the messaging system continues to function.
+        private static readonly Regex Dxmsg007Regex = new(
+            @"^'(?<type>[^']+)'\s+hides\s+MessageAwareComponent\.(?<method>[A-Za-z_][A-Za-z0-9_]*)\s+with\s+'new'\s*;\s*replace\s+with\s+'override'\s+and\s+call\s+base\.[A-Za-z_][A-Za-z0-9_]*\(\)\s+so\s+the\s+messaging\s+system\s+continues\s+to\s+function\.",
+            SharedOptions
+        );
+
+        // DXMSG008 format:
+        //   '{type}' is excluded from the DxMessaging base-call check ({source}).
+        // No method name in the message; MethodName is returned as the empty string.
+        private static readonly Regex Dxmsg008Regex = new(
+            @"^'(?<type>[^']+)'\s+is\s+excluded\s+from\s+the\s+DxMessaging\s+base-call\s+check\s+\([^)]*\)\.",
+            SharedOptions
+        );
+
+        // DXMSG009 format:
+        //   '{type}' declares {method} without 'override' or 'new'; this implicitly hides
+        //   MessageAwareComponent.{method} (CS0114) and the messaging system will not function. ...
+        // We anchor on the head of the message and stop after the modifier-tokens phrase so future
+        // wording tweaks to the trailing remediation text don't break the parser.
+        private static readonly Regex Dxmsg009Regex = new(
+            @"^'(?<type>[^']+)'\s+declares\s+(?<method>[A-Za-z_][A-Za-z0-9_]*)\s+without\s+'override'\s+or\s+'new'",
+            SharedOptions
+        );
+
+        // DXMSG010 format:
+        //   '{type}' calls base.{method}() but the inherited override on '{broken}' does not
+        //   chain to MessageAwareComponent.{method}; the messaging system will not function
+        //   correctly on this component.
+        // We capture {type} (the class the user is editing), {method}, and the broken-ancestor
+        // FQN so the inspector overlay can mention "broken chain via {broken}" if desired.
+        private static readonly Regex Dxmsg010Regex = new(
+            @"^'(?<type>[^']+)'\s+calls\s+base\.(?<method>[A-Za-z_][A-Za-z0-9_]*)\(\)\s+but\s+the\s+inherited\s+override\s+on\s+'(?<broken>[^']+)'",
+            SharedOptions
+        );
+
+        /// <summary>
+        /// Parses one console log line. Returns <c>null</c> if the line is not a recognised
+        /// DXMSG006/DXMSG007/DXMSG008/DXMSG009/DXMSG010 message.
+        /// </summary>
+        /// <remarks>
+        /// Tolerates both the Roslyn-prefixed form (<c>Path(L,C): warning DXMSG006: ...</c>) and the
+        /// bare form (just the message body). The prefix's path/line are captured; the bare form
+        /// returns empty path / zero line.
+        /// </remarks>
+        public static ParsedEntry? ParseLine(string logLine)
+        {
+            if (string.IsNullOrWhiteSpace(logLine))
+            {
+                return null;
+            }
+
+            string filePath = string.Empty;
+            int line = 0;
+            string body = logLine;
+
+            Match prefixMatch = PrefixRegex.Match(logLine);
+            if (prefixMatch.Success)
+            {
+                filePath = prefixMatch.Groups["path"].Value;
+                if (
+                    !int.TryParse(
+                        prefixMatch.Groups["line"].Value,
+                        NumberStyles.Integer,
+                        CultureInfo.InvariantCulture,
+                        out line
+                    )
+                )
+                {
+                    line = 0;
+                }
+                body = logLine.Substring(prefixMatch.Length);
+            }
+
+            Match dxmsg006 = Dxmsg006Regex.Match(body);
+            if (dxmsg006.Success)
+            {
+                string type = dxmsg006.Groups["type"].Value;
+                string method = dxmsg006.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG006", type, method, filePath, line);
+                }
+            }
+
+            Match dxmsg007 = Dxmsg007Regex.Match(body);
+            if (dxmsg007.Success)
+            {
+                string type = dxmsg007.Groups["type"].Value;
+                string method = dxmsg007.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG007", type, method, filePath, line);
+                }
+            }
+
+            Match dxmsg008 = Dxmsg008Regex.Match(body);
+            if (dxmsg008.Success)
+            {
+                string type = dxmsg008.Groups["type"].Value;
+                if (!string.IsNullOrWhiteSpace(type))
+                {
+                    return new ParsedEntry("DXMSG008", type, string.Empty, filePath, line);
+                }
+            }
+
+            Match dxmsg009 = Dxmsg009Regex.Match(body);
+            if (dxmsg009.Success)
+            {
+                string type = dxmsg009.Groups["type"].Value;
+                string method = dxmsg009.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG009", type, method, filePath, line);
+                }
+            }
+
+            Match dxmsg010 = Dxmsg010Regex.Match(body);
+            if (dxmsg010.Success)
+            {
+                string type = dxmsg010.Groups["type"].Value;
+                string method = dxmsg010.Groups["method"].Value;
+                if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(method))
+                {
+                    return new ParsedEntry("DXMSG010", type, method, filePath, line);
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Aggregates many log lines into a per-type report keyed by FQN. Deduplicates methods and
+        /// diagnostic ids ordinally; method names are stored in deterministic ordinal-sorted order.
+        /// Preserves first-occurrence for <see cref="ParsedTypeReport.FilePath"/> /
+        /// <see cref="ParsedTypeReport.Line"/>.
+        /// </summary>
+        public static Dictionary<string, ParsedTypeReport> Aggregate(IEnumerable<string> logLines)
+        {
+            Dictionary<string, ParsedTypeReport> result = new(StringComparer.Ordinal);
+            if (logLines == null)
+            {
+                return result;
+            }
+
+            foreach (string logLine in logLines)
+            {
+                ParsedEntry? parsed = ParseLine(logLine);
+                if (parsed is not ParsedEntry entry)
+                {
+                    continue;
+                }
+
+                if (!result.TryGetValue(entry.TypeFullName, out ParsedTypeReport report))
+                {
+                    report = new ParsedTypeReport { TypeFullName = entry.TypeFullName };
+                    result[entry.TypeFullName] = report;
+                }
+
+                report.DiagnosticIds.Add(entry.DiagnosticId);
+
+                if (!string.IsNullOrEmpty(entry.MethodName))
+                {
+                    report.MissingBaseFor.Add(entry.MethodName);
+                }
+
+                if (string.IsNullOrEmpty(report.FilePath) && !string.IsNullOrEmpty(entry.FilePath))
+                {
+                    report.FilePath = entry.FilePath;
+                    report.Line = entry.Line;
+                }
+            }
+
+            return result;
+        }
+    }
+}

package/Editor/Analyzers/BaseCallLogMessageParser.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a17c13ebe9604cee9bfa08d2517a3fad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: