private bool BindBreakpoint(ITypeMirror type, IBreakpoint bp)
{
foreach (var method in type.Methods)
{
var bestLocation = BestLocationIn(method, bp);
if (bestLocation == null)
{
continue;
}
var b = Factory.CreateBreakpoint(bestLocation);
breakpoints[bp] = b;
if (bp.Enabled)
{
b.Enable();
}
if (BreakpointBound != null)
{
BreakpointBound(bp, b, b.Location);
}
return(true);
}
return(false);
}
private string GetSerializedATN(ITypeMirror recognizerClass)
{
IList <IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
)processingEnv.GetTypeUtils().AsElement(recognizerClass));
foreach (IElement element in elements)
{
if (element.GetKind() != ElementKind.Field)
{
continue;
}
IVariableElement field = (IVariableElement)element;
bool isStatic = element.GetModifiers().Contains(Modifier.Static);
object constantValue = field.GetConstantValue();
bool isString = constantValue is string;
string name = field.GetSimpleName().ToString();
if (isStatic && isString && name.Equals("_serializedATN"))
{
return((string)constantValue);
}
}
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Could not retrieve serialized ATN from grammar."
);
return(null);
}
private RuleDependencyProcessor.RuleRelations ExtractRuleRelations(ITypeMirror recognizer)
{
string serializedATN = GetSerializedATN(recognizer);
if (serializedATN == null)
{
return(null);
}
ATN atn = new ATNDeserializer().Deserialize(serializedATN.ToCharArray());
RuleDependencyProcessor.RuleRelations relations = new RuleDependencyProcessor.RuleRelations(atn.ruleToStartState.Length);
foreach (ATNState state in atn.states)
{
if (!state.epsilonOnlyTransitions)
{
continue;
}
foreach (Transition transition in state.Transitions)
{
if (transition.TransitionType != TransitionType.Rule)
{
continue;
}
RuleTransition ruleTransition = (RuleTransition)transition;
relations.AddRuleInvocation(state.ruleIndex, ruleTransition.target.ruleIndex);
}
}
return(relations);
}
public override bool Process <_T0>(HashSet <_T0> annotations, IRoundEnvironment roundEnv)
{
if (!CheckClassNameConstants())
{
return(true);
}
IList <Tuple <RuleDependency, IElement> > dependencies = GetDependencies(roundEnv);
IDictionary <ITypeMirror, IList <Tuple <RuleDependency, IElement> > > recognizerDependencies = new Dictionary <ITypeMirror, IList <Tuple <RuleDependency, IElement> > >();
foreach (Tuple <RuleDependency, IElement> dependency in dependencies)
{
ITypeMirror recognizerType = GetRecognizerType(dependency.Item1);
IList <Tuple <RuleDependency, IElement> > list = recognizerDependencies.Get(recognizerType);
if (list == null)
{
list = new List <Tuple <RuleDependency, IElement> >();
recognizerDependencies.Put(recognizerType, list);
}
list.Add(dependency);
}
foreach (KeyValuePair <ITypeMirror, IList <Tuple <RuleDependency, IElement> > > entry in recognizerDependencies.EntrySet())
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Note, string.Format("ANTLR 4: Validating {0} dependencies on rules in {1}.", entry.Value.Count, entry.Key.ToString()));
CheckDependencies(entry.Value, entry.Key);
}
return(true);
}
private int[] GetRuleVersions(ITypeMirror recognizerClass, string[] ruleNames)
{
int[] versions = new int[ruleNames.Length];
IList <IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass));
foreach (IElement element in elements)
{
if (element.GetKind() != ElementKind.Field)
{
continue;
}
IVariableElement field = (IVariableElement)element;
bool isStatic = element.GetModifiers().Contains(Modifier.Static);
object constantValue = field.GetConstantValue();
bool isInteger = constantValue is int;
string name = field.GetSimpleName().ToString();
if (isStatic && isInteger && name.StartsWith("RULE_"))
{
try
{
name = Sharpen.Runtime.Substring(name, "RULE_".Length);
if (name.IsEmpty() || !System.Char.IsLower(name[0]))
{
continue;
}
int index = (int)constantValue;
if (index < 0 || index >= versions.Length)
{
string message = string.Format("Rule index {0} for rule '{1}' out of bounds for recognizer {2}.", index, name, recognizerClass.ToString());
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
continue;
}
if (name.IndexOf(ATNSimulator.RuleVariantDelimiter) >= 0)
{
// ignore left-factored pseudo-rules
continue;
}
IExecutableElement ruleMethod = GetRuleMethod(recognizerClass, name);
if (ruleMethod == null)
{
string message = string.Format("Could not find rule method for rule '{0}' in recognizer {1}.", name, recognizerClass.ToString());
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, element);
continue;
}
RuleVersion ruleVersion = ruleMethod.GetAnnotation <RuleVersion>();
int version = ruleVersion != null?ruleVersion.Value() : 0;
versions[index] = version;
}
catch (ArgumentException)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies.", element);
}
}
}
return(versions);
}
private void OnTypeUnloaded(ITypeMirror typeMirror)
{
var bps = breakpoints.Where(x => typeMirror.SourceFiles.Contains(x.Value.Location.SourceFile)).ToArray();
foreach (var bp in bps)
{
breakpoints.Remove(bp.Key);
}
}
public MethodMirror(string fullName, string name, ITypeMirror type, int token, MethodDefinition def, ILocation[] locations)
{
this.FullName = fullName;
this.Name = name;
this.DeclaringType = type;
this.MetadataToken = token;
this.metadata = def;
this.locations = locations;
}
public MethodMirror(string fullName, string name, ITypeMirror type, ITypeMirror returnType, int token, MethodDefinition def, ILocation[] locations)
{
this.FullName = fullName;
this.Name = name;
this.DeclaringType = type;
this.ReturnType = returnType;
this.MetadataToken = token;
this.metadata = def;
this.locations = locations;
}
public void TypeLoaded_PublishesEvent()
{
vm.Reset();
ITypeMirror loadedType = null;
typeProvider.TypeLoaded += mirror => loadedType = mirror;
vm.LoadAssembly(typeof(type1).Assembly.Location);
typeProvider.TypeLoaded += null;
Assert.IsNotNull(loadedType);
}
private void OnTypeLoaded(ITypeMirror type)
{
var sourcefiles = type.SourceFiles;
var relevantBreakpoints = Breakpoints.Where(bp => sourcefiles.Contains(bp.Location.SourceFile));
foreach (var bp in relevantBreakpoints)
{
BindBreakpoint(type, bp);
}
}
public void AssemblyUnload_Publishes_TypeUnloadEvents()
{
vm.Reset();
vm.LoadAssembly(typeof(type1).Assembly.Location);
ITypeMirror unloadedType = null;
typeProvider.TypeUnloaded += mirror => unloadedType = mirror;
vm.UnloadAssembly(typeof(type1).Assembly.FullName);
typeProvider.TypeLoaded += null;
Assert.IsNotNull(unloadedType);
}
private void OnTypeUnloaded(ITypeMirror typeMirror)
{
var bps = breakpoints.Where(x => typeMirror.SourceFiles.Contains(x.Value.Location.SourceFile)).ToArray();
foreach (var bp in bps)
{
if (BreakpointUnbound != null)
{
BreakpointUnbound(bp.Key, bp.Value, bp.Value.Location);
}
breakpoints[bp.Key] = null;
}
}
private string[] GetRuleNames(ITypeMirror recognizerClass)
{
IList <string> result = new List <string>();
IList <IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement
)processingEnv.GetTypeUtils().AsElement(recognizerClass));
foreach (IElement element in elements)
{
if (element.GetKind() != ElementKind.Field)
{
continue;
}
IVariableElement field = (IVariableElement)element;
bool isStatic = element.GetModifiers().Contains(Modifier.Static);
object constantValue = field.GetConstantValue();
bool isInteger = constantValue is int;
string name = field.GetSimpleName().ToString();
if (isStatic && isInteger && name.StartsWith("RULE_"))
{
try
{
name = Sharpen.Runtime.Substring(name, "RULE_".Length);
if (name.IsEmpty() || !System.Char.IsLower(name[0]))
{
continue;
}
int index = (int)constantValue;
if (index < 0)
{
continue;
}
while (result.Count <= index)
{
result.AddItem(string.Empty);
}
result.Set(index, name);
}
catch (ArgumentException)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, "Exception occurred while validating rule dependencies."
, element);
}
}
}
return(Sharpen.Collections.ToArray(result, new string[result.Count]));
}
private IExecutableElement GetRuleMethod(ITypeMirror recognizerClass, string name)
{
IList <IElement> elements = processingEnv.GetElementUtils().GetAllMembers((ITypeElement)processingEnv.GetTypeUtils().AsElement(recognizerClass));
foreach (IElement element in elements)
{
if (element.GetKind() != ElementKind.Method)
{
continue;
}
IExecutableElement method = (IExecutableElement)element;
if (method.GetSimpleName().ContentEquals(name) && HasRuleVersionAnnotation(method))
{
return(method);
}
}
return(null);
}
private void OnTypeLoaded(ITypeMirror type)
{
var sourcefiles = type.SourceFiles;
var relevantBreakpoints = breakpointProvider.Breakpoints.Where (bp => sourcefiles.Contains (bp.Location.SourceFile));
foreach (var bp in relevantBreakpoints)
{
foreach (var method in type.Methods)
{
var bestLocation = BestLocationIn (method, bp);
if (bestLocation == null)
continue;
var b = Factory.CreateBreakpoint (bestLocation);
breakpoints.Add (bp, b);
b.Enable ();
break;
}
}
}
private void OnTypeLoaded(ITypeMirror type)
{
var sourcefiles = type.SourceFiles;
var relevantBreakpoints = breakpoints.Where(bp => sourcefiles.Contains(bp.Key.Location.SourceFile));
foreach (var bp in relevantBreakpoints)
{
foreach (var method in type.Methods)
{
var bestLocation = BestLocationIn(method, bp.Key);
if (bestLocation == null)
{
continue;
}
var b = Factory.CreateBreakpoint(bestLocation);
breakpoints[bp.Key] = b;
b.Enable();
break;
}
}
}
private bool BindBreakpoint(ITypeMirror type, IBreakpoint bp)
{
foreach (var method in type.Methods)
{
var bestLocation = BestLocationIn (method, bp);
if (bestLocation == null)
continue;
var b = Factory.CreateBreakpoint (bestLocation);
breakpoints[bp] = b;
if (bp.Enabled) b.Enable ();
if (BreakpointBound != null)
BreakpointBound (bp, b, b.Location);
return true;
}
return false;
}
private IAnnotationValue FindRuleDependencyProperty(Tuple <RuleDependency, IElement> dependency, IAnnotationMirror annotationMirror, RuleDependencyProcessor.RuleDependencyProperty property)
{
IAnnotationValue recognizerValue = null;
IAnnotationValue ruleValue = null;
IAnnotationValue versionValue = null;
IAnnotationValue dependentsValue = null;
IDictionary <IExecutableElement, IAnnotationValue> values = annotationMirror.GetElementValues();
foreach (KeyValuePair <IExecutableElement, IAnnotationValue> value in values.EntrySet())
{
IAnnotationValue annotationValue = value.Value;
if ("rule()".Equals(value.Key.ToString()))
{
ruleValue = annotationValue;
if (!(annotationValue.GetValue() is int))
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'rule()'.", dependency.Item2, annotationMirror, annotationValue);
return(null);
}
if ((int)annotationValue.GetValue() != dependency.Item1.Rule())
{
// this is a valid dependency annotation, but not the one we're looking for
return(null);
}
}
else
{
if ("recognizer()".Equals(value.Key.ToString()))
{
recognizerValue = annotationValue;
if (!(annotationValue.GetValue() is ITypeMirror))
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected Class constant for annotation property 'recognizer()'.", dependency.Item2, annotationMirror, annotationValue);
return(null);
}
ITypeMirror annotationRecognizer = (ITypeMirror)annotationValue.GetValue();
ITypeMirror expectedRecognizer = GetRecognizerType(dependency.Item1);
if (!processingEnv.GetTypeUtils().IsSameType(expectedRecognizer, annotationRecognizer))
{
// this is a valid dependency annotation, but not the one we're looking for
return(null);
}
}
else
{
if ("version()".Equals(value.Key.ToString()))
{
versionValue = annotationValue;
if (!(annotationValue.GetValue() is int))
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Expected int constant for annotation property 'version()'.", dependency.Item2, annotationMirror, annotationValue);
return(null);
}
if ((int)annotationValue.GetValue() != dependency.Item1.Version())
{
// this is a valid dependency annotation, but not the one we're looking for
return(null);
}
}
}
}
}
if (recognizerValue != null)
{
if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
{
return(recognizerValue);
}
else
{
if (ruleValue != null)
{
if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
{
return(ruleValue);
}
else
{
if (versionValue != null)
{
if (property == RuleDependencyProcessor.RuleDependencyProperty.Version)
{
return(versionValue);
}
else
{
if (property == RuleDependencyProcessor.RuleDependencyProperty.Dependents)
{
return(dependentsValue);
}
}
}
}
}
}
}
if (recognizerValue == null)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'recognizer()' element in annotation.", dependency.Item2, annotationMirror);
}
if (property == RuleDependencyProcessor.RuleDependencyProperty.Recognizer)
{
return(null);
}
if (ruleValue == null)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'rule()' element in annotation.", dependency.Item2, annotationMirror);
}
if (property == RuleDependencyProcessor.RuleDependencyProperty.Rule)
{
return(null);
}
if (versionValue == null)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, "Could not find 'version()' element in annotation.", dependency.Item2, annotationMirror);
}
return(null);
}
public TypeEvent(ITypeMirror type)
{
Type = type;
}
public TypeEvent(ITypeMirror type)
{
Type = type;
}
private void OnTypeLoaded(ITypeMirror type)
{
var sourcefiles = type.SourceFiles;
var relevantBreakpoints = Breakpoints.Where (bp => sourcefiles.Contains (bp.Location.SourceFile));
foreach (var bp in relevantBreakpoints)
BindBreakpoint (type, bp);
}
private void CheckDependencies(IList <Tuple <RuleDependency, IElement> > dependencies, ITypeMirror recognizerType)
{
string[] ruleNames = GetRuleNames(recognizerType);
int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
RuleDependencyProcessor.RuleRelations relations = ExtractRuleRelations(recognizerType);
foreach (Tuple <RuleDependency, IElement> dependency in dependencies)
{
try
{
if (!processingEnv.GetTypeUtils().IsAssignable(GetRecognizerType(dependency.Item1), 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)
{
Tuple <IAnnotationMirror, IAnnotationValue> ruleReferenceElement = FindRuleDependencyProperty(dependency, RuleDependencyProcessor.RuleDependencyProperty.Rule);
string message = string.Format("Rule dependency on unknown rule {0}@{1} in {2}", dependency.Item1.Rule(), dependency.Item1.Version(), GetRecognizerType(dependency.Item1).ToString());
if (ruleReferenceElement != null)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency.Item2, ruleReferenceElement.Item1, ruleReferenceElement.Item2);
}
else
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency.Item2);
}
continue;
}
EnumSet <Dependents> dependents = EnumSet.Of(Dependents.Self, dependency.Item1.Dependents());
ReportUnimplementedDependents(dependency, dependents);
BitSet @checked = new BitSet();
int highestRequiredDependency = CheckDependencyVersion(dependency, ruleNames, ruleVersions, effectiveRule, null);
if (dependents.Contains(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(dependency, ruleNames, ruleVersions, parent, "parent");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
if (dependents.Contains(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(dependency, ruleNames, ruleVersions, child, "child");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
if (dependents.Contains(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(dependency, ruleNames, ruleVersions, ancestor, "ancestor");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
if (dependents.Contains(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(dependency, ruleNames, ruleVersions, descendant, "descendant");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
int declaredVersion = dependency.Item1.Version();
if (declaredVersion > highestRequiredDependency)
{
Tuple <IAnnotationMirror, IAnnotationValue> versionElement = FindRuleDependencyProperty(dependency, RuleDependencyProcessor.RuleDependencyProperty.Version);
string message = string.Format("Rule dependency version mismatch: {0} has maximum dependency version {1} (expected {2}) in {3}", ruleNames[dependency.Item1.Rule()], highestRequiredDependency, declaredVersion, GetRecognizerType(dependency.Item1).ToString());
if (versionElement != null)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency.Item2, versionElement.Item1, versionElement.Item2);
}
else
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Error, message, dependency.Item2);
}
}
}
catch (AnnotationTypeMismatchException)
{
processingEnv.GetMessager().PrintMessage(Diagnostic.Kind.Warning, string.Format("Could not validate rule dependencies for element {0}", dependency.Item2.ToString()), dependency.Item2);
}
}
}
private void OnTypeUnloaded(ITypeMirror typeMirror)
{
var bps = breakpoints.Where (x => typeMirror.SourceFiles.Contains(x.Value.Location.SourceFile)).ToArray ();
foreach (var bp in bps)
breakpoints.Remove (bp.Key);
}
private void OnTypeUnloaded(ITypeMirror typeMirror)
{
var bps = breakpoints.Where (x => typeMirror.SourceFiles.Contains(x.Value.Location.SourceFile)).ToArray ();
foreach (var bp in bps) {
if (BreakpointUnbound != null)
BreakpointUnbound (bp.Key, bp.Value, bp.Value.Location);
breakpoints[bp.Key] = null;
}
}
