antlr/runtime/CSharp/Antlr4.Runtime/Misc/RuleDependencyChecker.cs

/*
 * [The "BSD license"]
 *  Copyright (c) 2013 Terence Parr
 *  Copyright (c) 2013 Sam Harwell
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Security;
using System.Text;
using Antlr4.Runtime;
using Antlr4.Runtime.Atn;
using Antlr4.Runtime.Misc;
using Sharpen;

namespace Antlr4.Runtime.Misc
{
    /// <author>Sam Harwell</author>
    public class RuleDependencyChecker
    {
#if false
        private static readonly Logger Logger = Logger.GetLogger(typeof(Antlr4.Runtime.Misc.RuleDependencyChecker
            ).FullName);
#endif

        private static readonly ISet<Type> checkedTypes = new HashSet<Type>();

        public static void CheckDependencies(Type dependentClass)
        {
            if (IsChecked(dependentClass))
            {
                return;
            }
            IList<Type> typesToCheck = GetTypesToCheck(dependentClass);
            foreach (Type clazz in typesToCheck)
            {
                if (IsChecked(clazz))
                {
                    continue;
                }
                IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> dependencies = GetDependencies(clazz
                    );
                if (dependencies.Count == 0)
                {
                    continue;
                }
                IDictionary<Type, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>> recognizerDependencies
                     = new Dictionary<Type, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>>();
                foreach (Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
                {
                    Type recognizerType = dependency.Item1.Recognizer;
                    IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> list = recognizerDependencies.Get
                        (recognizerType);
                    if (list == null)
                    {
                        list = new List<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>();
                        recognizerDependencies.Put(recognizerType, list);
                    }
                    list.Add(dependency);
                }
                foreach (KeyValuePair<Type, IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>>> entry
                     in recognizerDependencies)
                {
                    //processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, String.format("ANTLR 4: Validating %d dependencies on rules in %s.", entry.getValue().size(), entry.getKey().toString()));
                    CheckDependencies(entry.Value, entry.Key);
                }
                CheckDependencies(dependencies, dependencies[0].Item1.Recognizer);
            }
        }

        private static IList<Type> GetTypesToCheck(Type clazz)
        {
            ISet<Type> result = new HashSet<Type>();
            GetTypesToCheck(clazz, result);
            return new List<Type>(result);
        }

        private static void GetTypesToCheck(Type clazz, ISet<Type> result)
        {
            if (!result.Add(clazz))
            {
                return;
            }
            foreach (Type declared in clazz.GetNestedTypes())
            {
                GetTypesToCheck(declared, result);
            }
        }

        private static bool IsChecked(Type clazz)
        {
            lock (checkedTypes)
            {
                return checkedTypes.Contains(clazz);
            }
        }

        private static void MarkChecked(Type clazz)
        {
            lock (checkedTypes)
            {
                checkedTypes.Add(clazz);
            }
        }

        private static void CheckDependencies(IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider
            >> dependencies, Type recognizerType)
        {
            string[] ruleNames = GetRuleNames(recognizerType);
            int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
            RuleDependencyChecker.RuleRelations relations = ExtractRuleRelations(recognizerType
                );
            StringBuilder errors = new StringBuilder();
            foreach (Tuple<RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
            {
                if (!dependency.Item1.Recognizer.IsAssignableFrom(recognizerType))
                {
                    continue;
                }
                // this is the rule in the dependency set with the highest version number
                int effectiveRule = dependency.Item1.Rule;
                if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
                {
                    string message = string.Format("Rule dependency on unknown rule %d@%d in %s%n", dependency
                        .Item1.Rule, dependency.Item1.Version, dependency.Item1.Recognizer.ToString
                        ());
                    errors.Append(message);
                    continue;
                }
                Dependents dependents = Dependents.Self | dependency.Item1.Dependents;
                ReportUnimplementedDependents(errors, dependency, dependents);
                BitSet @checked = new BitSet();
                int highestRequiredDependency = CheckDependencyVersion(errors, dependency, ruleNames
                    , ruleVersions, effectiveRule, null);
                if (dependents.HasFlag(Dependents.Parents))
                {
                    BitSet parents = relations.parents[dependency.Item1.Rule];
                    for (int parent = parents.NextSetBit(0); parent >= 0; parent = parents.NextSetBit
                        (parent + 1))
                    {
                        if (parent < 0 || parent >= ruleVersions.Length || @checked.Get(parent))
                        {
                            continue;
                        }
                        @checked.Set(parent);
                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions
                            , parent, "parent");
                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
                    }
                }
                if (dependents.HasFlag(Dependents.Children))
                {
                    BitSet children = relations.children[dependency.Item1.Rule];
                    for (int child = children.NextSetBit(0); child >= 0; child = children.NextSetBit(
                        child + 1))
                    {
                        if (child < 0 || child >= ruleVersions.Length || @checked.Get(child))
                        {
                            continue;
                        }
                        @checked.Set(child);
                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions
                            , child, "child");
                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
                    }
                }
                if (dependents.HasFlag(Dependents.Ancestors))
                {
                    BitSet ancestors = relations.GetAncestors(dependency.Item1.Rule);
                    for (int ancestor = ancestors.NextSetBit(0); ancestor >= 0; ancestor = ancestors.
                        NextSetBit(ancestor + 1))
                    {
                        if (ancestor < 0 || ancestor >= ruleVersions.Length || @checked.Get(ancestor))
                        {
                            continue;
                        }
                        @checked.Set(ancestor);
                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions
                            , ancestor, "ancestor");
                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
                    }
                }
                if (dependents.HasFlag(Dependents.Descendants))
                {
                    BitSet descendants = relations.GetDescendants(dependency.Item1.Rule);
                    for (int descendant = descendants.NextSetBit(0); descendant >= 0; descendant = descendants
                        .NextSetBit(descendant + 1))
                    {
                        if (descendant < 0 || descendant >= ruleVersions.Length || @checked.Get(descendant
                            ))
                        {
                            continue;
                        }
                        @checked.Set(descendant);
                        int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions
                            , descendant, "descendant");
                        highestRequiredDependency = Math.Max(highestRequiredDependency, required);
                    }
                }
                int declaredVersion = dependency.Item1.Version;
                if (declaredVersion > highestRequiredDependency)
                {
                    string message = string.Format("Rule dependency version mismatch: %s has maximum dependency version %d (expected %d) in %s%n"
                        , ruleNames[dependency.Item1.Rule], highestRequiredDependency, declaredVersion
                        , dependency.Item1.Recognizer.ToString());
                    errors.Append(message);
                }
            }
            if (errors.Length > 0)
            {
                throw new InvalidOperationException(errors.ToString());
            }
            MarkChecked(recognizerType);
        }

        private static readonly Dependents ImplementedDependents = Dependents
            .Self | Dependents.Parents | Dependents.Children | Dependents.Ancestors | Dependents
            .Descendants;

        private static void ReportUnimplementedDependents(StringBuilder errors, Tuple<RuleDependencyAttribute
            , ICustomAttributeProvider> dependency, Dependents dependents)
        {
            Dependents unimplemented = dependents;
            unimplemented &= ~ImplementedDependents;
            if (unimplemented != Dependents.None)
            {
                string message = string.Format("Cannot validate the following dependents of rule %d: %s%n"
                    , dependency.Item1.Rule, unimplemented);
                errors.Append(message);
            }
        }

        private static int CheckDependencyVersion(StringBuilder errors, Tuple<RuleDependencyAttribute
            , ICustomAttributeProvider> dependency, string[] ruleNames, int[] ruleVersions, int 
            relatedRule, string relation)
        {
            string ruleName = ruleNames[dependency.Item1.Rule];
            string path;
            if (relation == null)
            {
                path = ruleName;
            }
            else
            {
                string mismatchedRuleName = ruleNames[relatedRule];
                path = string.Format("rule %s (%s of %s)", mismatchedRuleName, relation, ruleName
                    );
            }
            int declaredVersion = dependency.Item1.Version;
            int actualVersion = ruleVersions[relatedRule];
            if (actualVersion > declaredVersion)
            {
                string message = string.Format("Rule dependency version mismatch: %s has version %d (expected <= %d) in %s%n"
                    , path, actualVersion, declaredVersion, dependency.Item1.Recognizer.ToString
                    ());
                errors.Append(message);
            }
            return actualVersion;
        }

        private static int[] GetRuleVersions(Type recognizerClass, string[] ruleNames
            )
        {
            int[] versions = new int[ruleNames.Length];
            FieldInfo[] fields = recognizerClass.GetFields();
            foreach (FieldInfo field in fields)
            {
                bool isStatic = field.IsStatic;
                bool isInteger = field.FieldType == typeof(int);
                if (isStatic && isInteger && field.Name.StartsWith("RULE_"))
                {
                    try
                    {
                        string name = field.Name.Substring("RULE_".Length);
                        if (name.Length == 0 || !System.Char.IsLower(name[0]))
                        {
                            continue;
                        }
                        int index = (int)field.GetValue(null);
                        if (index < 0 || index >= versions.Length)
                        {
                            object[] @params = new object[] { index, field.Name, recognizerClass.Name };
#if false
                            Logger.Log(Level.Warning, "Rule index {0} for rule ''{1}'' out of bounds for recognizer {2}."
                                , @params);
#endif
                            continue;
                        }
                        MethodInfo ruleMethod = GetRuleMethod(recognizerClass, name);
                        if (ruleMethod == null)
                        {
                            object[] @params = new object[] { name, recognizerClass.Name };
#if false
                            Logger.Log(Level.Warning, "Could not find rule method for rule ''{0}'' in recognizer {1}."
                                , @params);
#endif
                            continue;
                        }
                        RuleVersionAttribute ruleVersion = ruleMethod.GetCustomAttribute<RuleVersionAttribute>();
                        int version = ruleVersion != null ? ruleVersion.Version : 0;
                        versions[index] = version;
                    }
                    catch (ArgumentException ex)
                    {
#if false
                        Logger.Log(Level.Warning, null, ex);
#endif
                    }
                    catch (MemberAccessException ex)
                    {
#if false
                        Logger.Log(Level.Warning, null, ex);
#endif
                    }
                }
            }
            return versions;
        }

        private static MethodInfo GetRuleMethod(Type recognizerClass, string name
            )
        {
            MethodInfo[] declaredMethods = recognizerClass.GetMethods();
            foreach (MethodInfo method in declaredMethods)
            {
                if (method.Name.Equals(name) && method.GetCustomAttribute<RuleVersionAttribute>() != null)
                {
                    return method;
                }
            }
            return null;
        }

        private static string[] GetRuleNames(Type recognizerClass)
        {
            FieldInfo ruleNames = recognizerClass.GetField("ruleNames");
            return (string[])ruleNames.GetValue(null);
        }

        public static IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> GetDependencies(Type clazz)
        {
            IList<Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> result = new List<Tuple<RuleDependencyAttribute
                , ICustomAttributeProvider>>();

            GetElementDependencies(clazz, result);
            foreach (ConstructorInfo ctor in clazz.GetConstructors(BindingFlags.DeclaredOnly))
            {
                GetElementDependencies(ctor, result);
                foreach (ParameterInfo parameter in ctor.GetParameters())
                    GetElementDependencies(parameter, result);
            }

            foreach (FieldInfo field in clazz.GetFields(BindingFlags.DeclaredOnly))
            {
                GetElementDependencies(field, result);
            }

            foreach (MethodInfo method in clazz.GetMethods(BindingFlags.DeclaredOnly))
            {
                GetElementDependencies(method, result);
                if (method.ReturnParameter != null)
                    GetElementDependencies(method.ReturnParameter, result);

                foreach (ParameterInfo parameter in method.GetParameters())
                    GetElementDependencies(parameter, result);
            }

            return result;
        }

        private static void GetElementDependencies(ICustomAttributeProvider annotatedElement, IList
            <Tuple<RuleDependencyAttribute, ICustomAttributeProvider>> result)
        {
            foreach (RuleDependencyAttribute dependency in annotatedElement.GetCustomAttributes(typeof(RuleDependencyAttribute), true))
            {
                result.Add(Tuple.Create(dependency, annotatedElement));
            }
        }

        private static RuleDependencyChecker.RuleRelations ExtractRuleRelations(Type
             recognizer)
        {
            string serializedATN = GetSerializedATN(recognizer);
            if (serializedATN == null)
            {
                return null;
            }
            ATN atn = ATNSimulator.Deserialize(serializedATN.ToCharArray());
            RuleDependencyChecker.RuleRelations relations = new RuleDependencyChecker.RuleRelations
                (atn.ruleToStartState.Length);
            foreach (ATNState state in atn.states)
            {
                if (!state.epsilonOnlyTransitions)
                {
                    continue;
                }
                foreach (Transition transition in state.GetTransitions())
                {
                    if (transition.TransitionType != TransitionType.Rule)
                    {
                        continue;
                    }
                    RuleTransition ruleTransition = (RuleTransition)transition;
                    relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
                }
            }
            return relations;
        }

        private static string GetSerializedATN(Type recognizerClass)
        {
            FieldInfo serializedAtnField = recognizerClass.GetField("_serializedATN", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            if (serializedAtnField != null)
                return (string)serializedAtnField.GetValue(null);

            if (recognizerClass.BaseType != null)
                return GetSerializedATN(recognizerClass.BaseType);

            return null;
        }

        private sealed class RuleRelations
        {
            public readonly BitSet[] parents;

            public readonly BitSet[] children;

            public RuleRelations(int ruleCount)
            {
                parents = new BitSet[ruleCount];
                for (int i = 0; i < ruleCount; i++)
                {
                    parents[i] = new BitSet();
                }
                children = new BitSet[ruleCount];
                for (int i_1 = 0; i_1 < ruleCount; i_1++)
                {
                    children[i_1] = new BitSet();
                }
            }

            public bool AddRuleInvocation(int caller, int callee)
            {
                if (caller < 0)
                {
                    // tokens rule
                    return false;
                }
                if (children[caller].Get(callee))
                {
                    // already added
                    return false;
                }
                children[caller].Set(callee);
                parents[callee].Set(caller);
                return true;
            }

            public BitSet GetAncestors(int rule)
            {
                BitSet ancestors = new BitSet();
                ancestors.Or(parents[rule]);
                while (true)
                {
                    int cardinality = ancestors.Cardinality();
                    for (int i = ancestors.NextSetBit(0); i >= 0; i = ancestors.NextSetBit(i + 1))
                    {
                        ancestors.Or(parents[i]);
                    }
                    if (ancestors.Cardinality() == cardinality)
                    {
                        // nothing changed
                        break;
                    }
                }
                return ancestors;
            }

            public BitSet GetDescendants(int rule)
            {
                BitSet descendants = new BitSet();
                descendants.Or(children[rule]);
                while (true)
                {
                    int cardinality = descendants.Cardinality();
                    for (int i = descendants.NextSetBit(0); i >= 0; i = descendants.NextSetBit(i + 1))
                    {
                        descendants.Or(children[i]);
                    }
                    if (descendants.Cardinality() == cardinality)
                    {
                        // nothing changed
                        break;
                    }
                }
                return descendants;
            }
        }

        private RuleDependencyChecker()
        {
        }
    }
}