Jan Kinable :
Hey Steve,
I finally found some time to look into your contribution. It’s a pitty but I will not incorporate your solution and this for the very simple reason that it has too much dependencies to third party assemblies. NRefactory -> mono.cecil and to be able to build this I must install NUnit. I notice that you are favorit to open source software. I don’t hold anything against it but when you want to build a package you want to prevent including to much assemblies. If every contributor would port their 3th party assembly, sooner or later you will end-up with a version clash. I like clean solutions, thus only the tools VS/MS offers.

Not a problem. I share your opinion for the most part. When I get some free time I am planning on refactoring NRefactory out for the reasons you specify.

Also, thanks for the tip about the SComponentModel service, I completely missed that!

I do use this feature but you are forgetting there is already a container created by VS. You can get to it by resolving the IComponentModel through the ServiceProvider:
IComponentModel componentModel = GetService(typeof(SComponentModel)) as IComponentModel;

Then you can create your DirectoryCatalog and aggregate it with the existing one:
DirectoryCatalog directoryCatalog = ...;
AggregateCatalog = new AggregateCatelog(componentModel.DefaultCatalog, directoryCatalog);

You have to make use of a CompositionBatch (allows you to dynamically add/remove parts):
CompositionBatch compositionBatch = new CompositionBatch();
CompositionContainer container = new CompositionContainer(aggregateCatalog);
container.Compose(compositionBatch);
And your done.

Me again! I have been working on the extensibility side of this add-in now. I have found that if you change the ComposeContainer method to;

AggregateCatalog cat = new AggregateCatalog();
CompositionContainer _container;

protected void ComposeContainer()
{
FileInfo assembly = new FileInfo(Assembly.GetExecutingAssembly().Location);

this.cat.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
this.cat.Catalogs.Add(new DirectoryCatalog(assembly.Directory + “\\extensions”));

_container = new CompositionContainer(this.cat);

//Fill the imports of this object
try
{
this._container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
}

Then you can drop assemblies into the extensions sub-folder without having to register them as MEF components. It works equally well with your suggested “C:\FxCopExtensions” too.

Hope you find this useful.

Steve

var variableDeclarations =
parser.CompilationUnit.Children
.FindMethods(x => x.Children, methodName)
.FindLocalVariables(x => x.Children, variableName)
.OrderByDescending(x => x.StartLocation.Line)
.ToList();

The above statement finds a specified variable within the specified method name. I then use the list within a for loop as below;

foreach (var localVariableDeclaration in variableDeclarations)
{
INode parentNode = localVariableDeclaration.Parent;

if (parentNode is BlockStatement && parentNode.StartLocation.Line = lineNumber)
{
IdentifierExpression identifierExpression = new IdentifierExpression(variableName);
MemberReferenceExpression memberReferenceExpression = new MemberReferenceExpression(identifierExpression, “Dispose”);
InvocationExpression invocationExpression = new InvocationExpression(memberReferenceExpression);

ExpressionStatement expressionStatement = new ExpressionStatement(invocationExpression);

INode insertBefore = this.GetInsertionStatement(parentNode, localVariableDeclaration.StartLocation.Line);

if (insertBefore == null)
{
parentNode.Children.Add(expressionStatement);
}
else
{
parentNode.Children.Insert(parentNode.Children.IndexOf(insertBefore), expressionStatement);
}

this.FixedLineNumber = parentNode.EndLocation.Line;
this.FixedColumnNumber = parentNode.EndLocation.Column;
}
}

This particular example adds a call to Dispose into the code for the variable specified in variableName.

Hope that all makes sense!

using ICSharpCode.NRefactory.Ast;

///
/// Extension methods for processing an enumeration if INode
///
public static class CodeParsingExtensions
{
///
/// The search criteria specified for a string literal search – Only used by FindStringLiteral
///
private static string stringliteralSearchCriteria = string.Empty;

///
/// The INodes matching the search criteria – Only used by FindStringLiteral
///
private static List searchMatches = null;

///
/// Finds the local variables with the specified variable name
///
/// The source enumeration
/// Delegate used when searching.
/// Name of the variable to locate.
/// IEnumerable containing INode that have the specified variable name (case sensitive)
public static IEnumerable FindLocalVariables(this IEnumerable source, Func<INode, IEnumerable> searchDelegate, string variableName)
{
return source.Traverse(x => x.Children)
.Where(x => x is LocalVariableDeclaration).Cast()
.Where(x => x.GetVariableDeclaration(variableName) != null);
}

///
/// Finds the methods with the specified name
///
/// The source enumeration to search
/// Delegate used when searching.
/// Name of the method (case sensitive)
/// IEnumerable containing INode that have the specified method name
public static IEnumerable FindMethods(this IEnumerable source, Func<INode, IEnumerable> searchDelegate, string methodName)
{
return source.Traverse(x => x.Children)
.Where(x => x is MethodDeclaration).Cast()
.Where(x => x.Name == methodName);
}

///
/// Finds the string literal
///
/// The source enumeration to search
/// Delegate used when searching.
/// Content of the literal (case sensitive)
/// IEnumerable of parent INodes containing the string literal.
public static IEnumerable FindStringLiteral(this IEnumerable source, Func<INode, IEnumerable> searchDelegate, string literalContent)
{
stringliteralSearchCriteria = literalContent;

// populated when expressions are evaluated
searchMatches = new List();

source.Traverse(x => x.Children).Where(x => x is ExpressionStatement).ToList();

return searchMatches;
}

///
/// Evaluates an expression and all nested expressions
///
/// The source enumeration
/// INode containing an expression
/// This is fairly ugly. In this instance the EvaluateExpression function is used only to support the FindStringLiteral method. It could be extended for more search methods if required.
private static INode EvaluateExpression(Expression source)
{
////ICSharpCode.NRefactory.Ast.QueryExpressionVB – unsupported right now

if (source is AddressOfExpression)
{
AddressOfExpression a = source as AddressOfExpression;
return EvaluateExpression(a.Expression);
}
else if (source is AnonymousMethodExpression)
{
AnonymousMethodExpression a = source as AnonymousMethodExpression;
foreach (Expression parameterExpression in a.Parameters)
{
if (null != EvaluateExpression(parameterExpression))
{
return a.Parent;
}
}
}
else if (source is ArrayCreateExpression)
{
ArrayCreateExpression a = source as ArrayCreateExpression;

if (null != EvaluateExpression(a.ArrayInitializer))
{
return a.Parent;
}

foreach (Expression argumentExpression in a.Arguments)
{
if (null != EvaluateExpression(argumentExpression))
{
return a.Parent;
}
}
}
else if (source is AssignmentExpression)
{
AssignmentExpression a = source as AssignmentExpression;

if (null != EvaluateExpression(a.Left))
{
return a.Parent;
}

if (null != EvaluateExpression(a.Right))
{
return a.Parent;
}
}
else if (source is BinaryOperatorExpression)
{
BinaryOperatorExpression b = source as BinaryOperatorExpression;

if (null != EvaluateExpression(b.Left))
{
return b.Parent;
}

if (null != EvaluateExpression(b.Right))
{
return b.Parent;
}
}
else if (source is CastExpression)
{
CastExpression c = source as CastExpression;

if (null != EvaluateExpression(c.Expression))
{
return c.Parent;
}
}
else if (source is CheckedExpression)
{
CheckedExpression c = source as CheckedExpression;
if (null != EvaluateExpression(c.Expression))
{
return c.Parent;
}
}
else if (source is CollectionInitializerExpression)
{
CollectionInitializerExpression c = source as CollectionInitializerExpression;
foreach (Expression createExpression in c.CreateExpressions)
{
if (null != EvaluateExpression(createExpression))
{
return c.Parent;
}
}
}
else if (source is ConditionalExpression)
{
ConditionalExpression c = source as ConditionalExpression;

if (null != EvaluateExpression(c.Condition))
{
return c.Parent;
}

if (null != EvaluateExpression(c.TrueExpression))
{
return c.Parent;
}

if (null != EvaluateExpression(c.FalseExpression))
{
return c.Parent;
}
}
else if (source is DirectionExpression)
{
DirectionExpression d = source as DirectionExpression;
if (null != EvaluateExpression(d.Expression))
{
return d.Parent;
}
}
else if (source is InvocationExpression)
{
InvocationExpression i = source as InvocationExpression;

if (null != EvaluateExpression(i.TargetObject))
{
return i.Parent;
}

foreach (Expression argumentExpression in i.Arguments)
{
if (null != EvaluateExpression(argumentExpression))
{
return i.Parent;
}
}
}
else if (source is IdentifierExpression)
{
IdentifierExpression id = source as IdentifierExpression;
}
else if (source is IndexerExpression)
{
IndexerExpression id = source as IndexerExpression;
foreach (Expression indexExpression in id.Indexes)
{
if (null != EvaluateExpression(indexExpression))
{
return id.Parent;
}
}
}
else if (source is LambdaExpression)
{
LambdaExpression l = source as LambdaExpression;
if (null != EvaluateExpression(l.ExpressionBody))
{
return l.Parent;
}
}
else if (source is MemberInitializerExpression)
{
MemberInitializerExpression m = source as MemberInitializerExpression;
if (null != EvaluateExpression(m.Expression))
{
return m.Parent;
}
}
else if (source is MemberReferenceExpression)
{
MemberReferenceExpression m = source as MemberReferenceExpression;
if (null != EvaluateExpression(m.TargetObject))
{
return m.Parent;
}
}
else if (source is NamedArgumentExpression)
{
NamedArgumentExpression n = source as NamedArgumentExpression;
if (null != EvaluateExpression(n.Expression))
{
return n.Parent;
}
}
else if (source is ObjectCreateExpression)
{
ObjectCreateExpression obj = source as ObjectCreateExpression;
if (null != EvaluateExpression(obj.ObjectInitializer))
{
return obj.Parent;
}

foreach (Expression parameterExpression in obj.Parameters)
{
if (null != EvaluateExpression(parameterExpression))
{
return obj.Parent;
}
}
}
else if (source is ParameterDeclarationExpression)
{
ParameterDeclarationExpression p = source as ParameterDeclarationExpression;

if (null != EvaluateExpression(p.DefaultValue))
{
return p.Parent;
}
}
else if (source is ParenthesizedExpression)
{
ParenthesizedExpression p = source as ParenthesizedExpression;
if (null != EvaluateExpression(p.Expression))
{
return p.Parent;
}
}
else if (source is PrimitiveExpression)
{
PrimitiveExpression p = source as PrimitiveExpression;

if (p.StringValue == string.Format(“\”{0}\”", stringliteralSearchCriteria))
{
searchMatches.Add(p.Parent);
return p.Parent;
}
}
else if (source is TypeOfIsExpression)
{
TypeOfIsExpression t = source as TypeOfIsExpression;
if (null != EvaluateExpression(t.Expression))
{
return t.Parent;
}
}
else if (source is UnaryOperatorExpression)
{
UnaryOperatorExpression u = source as UnaryOperatorExpression;
if (null != EvaluateExpression(u.Expression))
{
return u.Parent;
}
}
else if (source is UncheckedExpression)
{
UncheckedExpression u = source as UncheckedExpression;
if (null != EvaluateExpression(u.Expression))
{
return u.Parent;
}
}
else if (source is XmlAttributeExpression)
{
XmlAttributeExpression x = source as XmlAttributeExpression;
if (null != EvaluateExpression(x.ExpressionValue))
{
return x.Parent;
}
}
else if (source is XmlContentExpression)
{
XmlContentExpression x = source as XmlContentExpression;
}
else if (source is XmlDocumentExpression)
{
XmlDocumentExpression x = source as XmlDocumentExpression;
foreach (XmlExpression xmlExpression in x.Expressions)
{
if (null != EvaluateExpression(xmlExpression))
{
return x.Parent;
}
}
}
else if (source is XmlElementExpression)
{
XmlElementExpression x = source as XmlElementExpression;
if (null != EvaluateExpression(x.Content))
{
return x.Parent;
}

if (null != EvaluateExpression(x.NameExpression))
{
return x.Parent;
}
}
else if (source is XmlEmbeddedExpression)
{
XmlEmbeddedExpression x = source as XmlEmbeddedExpression;
if (null != EvaluateExpression(x.InlineVBExpression))
{
return x.Parent;
}
}
else if (source is XmlMemberAccessExpression)
{
XmlMemberAccessExpression x = source as XmlMemberAccessExpression;
if (null != EvaluateExpression(x.TargetObject))
{
return x.Parent;
}
}
else if (source is BaseReferenceExpression || source is ClassReferenceExpression ||
source is DefaultValueExpression || source is QueryExpression || source is TypeOfExpression ||
source is TypeReferenceExpression || source is ThisReferenceExpression ||
source is SizeOfExpression || source is XmlExpression)
{
// nothing to do
}
else if (“NullCollectionInitializerExpression” == source.GetType().Name || “NullExpression” == source.GetType().Name)
{
// cant do anything with this type – it is inaccessible
}

return null;
}

///
/// Traverses the code tree, navigating all INodes
///
/// The source enumeration
/// Delegate used when searching.
/// All INodes in a source file ready to be filtered by the appropriate “Find” method.
/// Not all statement types have been implemented as yet. I am implementing on a as needed basis.
private static IEnumerable Traverse(this IEnumerable source, Func<INode, IEnumerable> searchDelegate)
{
foreach (INode item in source)
{
yield return item;

IEnumerable seqRecurse = null;

if (item is MethodDeclaration)
{
MethodDeclaration method = item as MethodDeclaration;
seqRecurse = searchDelegate(method.Body);
}
else if (item is IfElseStatement)
{
IfElseStatement ifStatement = item as IfElseStatement;

foreach (Statement statement in ifStatement.TrueStatement)
{
if (statement is BlockStatement)
{
BlockStatement blockStatement = statement as BlockStatement;

foreach (INode itemRecurse in Traverse(blockStatement.Children, searchDelegate))
{
yield return itemRecurse;
}
}
}

if (ifStatement.HasElseStatements)
{
foreach (Statement statement in ifStatement.FalseStatement)
{
if (statement is BlockStatement)
{
BlockStatement blockStatement = statement as BlockStatement;

foreach (INode itemRecurse in Traverse(blockStatement.Children, searchDelegate))
{
yield return itemRecurse;
}
}
}
}

if (ifStatement.HasElseIfSections)
{
foreach (ElseIfSection elseIfSection in ifStatement.ElseIfSections)
{
foreach (INode itemRecurse in Traverse(elseIfSection.EmbeddedStatement.Children, searchDelegate))
{
yield return itemRecurse;
}
}
}
}
else if (item is SwitchStatement)
{
foreach (SwitchSection switchSection in (item as SwitchStatement).SwitchSections)
{
foreach (INode itemRecurse in Traverse(switchSection.Children, searchDelegate))
{
yield return itemRecurse;
}
}
}
else if (item is StatementWithEmbeddedStatement)
{
StatementWithEmbeddedStatement embeddedStatement = item as StatementWithEmbeddedStatement;
foreach (INode itemRecurse in Traverse(embeddedStatement.EmbeddedStatement.Children, searchDelegate))
{
yield return itemRecurse;
}
}
else if (item is TryCatchStatement)
{
TryCatchStatement tryCatch = item as TryCatchStatement;

foreach (INode itemRecurse in Traverse(tryCatch.StatementBlock.Children, searchDelegate))
{
yield return itemRecurse;
}

foreach (CatchClause catchClause in tryCatch.CatchClauses)
{
foreach (INode itemRecurse in Traverse(catchClause.StatementBlock.Children, searchDelegate))
{
yield return itemRecurse;
}
}

foreach (INode itemRecurse in Traverse(tryCatch.FinallyBlock.Children, searchDelegate))
{
yield return itemRecurse;
}
}
else if (item is ExpressionStatement)
{
INode node = EvaluateExpression(((ExpressionStatement)item).Expression);

if (null != node)
{
yield return node;
}
}
else
{
seqRecurse = searchDelegate(item);
}

if (seqRecurse != null)
{
foreach (INode itemRecurse in Traverse(seqRecurse, searchDelegate))
{
yield return itemRecurse;
}
}
}
}
}
}

///
/// Gets or sets the fixed line number.
///
///
/// The fixed line number.
///
///
/// This is the location in code where the fix has been applied, used to move the editor to the approximate position of the change
///
int FixedLineNumber { get; set; }

///
/// Gets or sets the fixed column number.
///
///
/// The fixed column number.
///
///
/// This is the location in code where the fix has been applied, used to move the editor to the approximate position of the change
///
int FixedColumnNumber { get; set; }

///
/// Gets a value indicating whether this instance is breaking rule.
///
///
/// true if this instance is breaking rule; otherwise, false.
///
bool IsBreakingRule { get; }

///
/// Gets the rule identifier.
///
string RuleIdentifier { get; }

///
/// Fixes the violation.
///
/// The original file.
/// The line number.
/// The column.
/// string, containing the fixed source code
string FixViolation(string originalFile, int? lineNumber, int? column);
}
}