StatementDependenciesHandler(ExpressionDependenciesHandler expressionHandler)
: super(false)
: super(false)
{
this.expressionHandler = expressionHandler ?? new ExpressionDependenciesHandler(this);
}
private static void addTypeMemberDependencies(TypeMemberNode tm, Set <TypeInfo> dependencies)
{
var t = tm.getUserData(typeof(TypeInfo));
if (t == null)
{
return;
}
addAnnotationsDependencies(t.Annotations, dependencies);
foreach (var ga in t.GenericArguments)
{
foreach (var b in ga.GenericParameterBounds)
{
addDependencies(b, dependencies);
}
}
ExpressionDependenciesHandler expressionHandler = null;
switch (tm.TypeMemberKind)
{
case Class:
var c = (ClassDeclarationNode)tm;
addDependencies(t.BaseType, dependencies);
foreach (var i in t.Interfaces)
{
addDependencies(i, dependencies);
}
foreach (var cm in c.Members)
{
switch (cm.TypeMemberKind)
{
case Class:
case Interface:
case Delegate:
addTypeMemberDependencies((TypeMemberNode)cm, dependencies);
break;
case EnumConstant:
var enumConstant = (EnumConstantDeclarationNode)cm;
addTypeMemberDependencies(enumConstant, dependencies);
foreach (var e in enumConstant.Arguments)
{
if (expressionHandler == null)
{
expressionHandler = new ExpressionDependenciesHandler(null);
}
expressionHandler.handleExpression(e, dependencies, true);
}
break;
case Field:
foreach (var decl in ((FieldDeclarationNode)cm).Declarators)
{
var f = decl.getUserData(typeof(FieldInfo));
addDependencies(f.Type, dependencies);
addAnnotationsDependencies(f.Annotations, dependencies);
if (decl.Value != null)
{
if (expressionHandler == null)
{
expressionHandler = new ExpressionDependenciesHandler(null);
}
expressionHandler.handleExpression(decl.Value, dependencies, true);
}
}
break;
case Constructor:
var constructor = (ConstructorDeclarationNode)cm;
addBodyDependencies(constructor.getUserData(typeof(MethodInfo)), constructor.Body, dependencies);
if (constructor.Initializer != null)
{
foreach (var e in constructor.Initializer.Arguments)
{
if (expressionHandler == null)
{
expressionHandler = new ExpressionDependenciesHandler(null);
}
expressionHandler.handleExpression(e, dependencies, true);
}
}
break;
case Destructor:
var destructor = (DestructorDeclarationNode)cm;
addBodyDependencies(destructor.getUserData(typeof(MethodInfo)), destructor.Body, dependencies);
break;
case Method:
var method = (MethodDeclarationNode)cm;
addBodyDependencies(method.getUserData(typeof(MethodInfo)), method.Body, dependencies);
break;
case Property:
case Indexer:
var accessorsOwner = (IAccessorsOwner)cm;
var get = accessorsOwner.getGetAccessor();
var set = accessorsOwner.getSetAccessor();
if (get != null)
{
addBodyDependencies(get.getUserData(typeof(MethodInfo)), get.Body, dependencies);
}
if (set != null)
{
addBodyDependencies(set.getUserData(typeof(MethodInfo)), set.Body, dependencies);
}
break;
}
}
break;
case Interface:
case Delegate:
foreach (var i in t.getInterfaces())
{
addDependencies(i, dependencies);
addAnnotationsDependencies(i.Annotations, dependencies);
}
foreach (var meth in t.Methods)
{
addDependencies(meth.ReturnType, dependencies);
addAnnotationsDependencies(meth.Annotations, dependencies);
foreach (var p in meth.Parameters)
{
addDependencies(p.Type, dependencies);
addAnnotationsDependencies(p.Annotations, dependencies);
}
}
break;
}
}
