private ExpressionAst CheckUsingExpression(ExpressionAst exprAst)
{
RuntimeHelpers.EnsureSufficientExecutionStack();
if (exprAst is VariableExpressionAst)
{
return(null);
}
MemberExpressionAst ast = exprAst as MemberExpressionAst;
if (((ast != null) && !(ast is InvokeMemberExpressionAst)) && (ast.Member is StringConstantExpressionAst))
{
return(this.CheckUsingExpression(ast.Expression));
}
IndexExpressionAst ast2 = exprAst as IndexExpressionAst;
if (ast2 == null)
{
return(exprAst);
}
if (!this.IsValidAttributeArgument(ast2.Index))
{
return(ast2.Index);
}
return(this.CheckUsingExpression(ast2.Target));
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
Type reflectionType = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
string name = ((StringConstantExpressionAst)memberExpressionAst.Member).Value;
return(((FieldInfo)reflectionType.GetMember(name, MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase)[0]).GetValue(null));
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
if (!memberExpressionAst.Static || !(memberExpressionAst.Expression is TypeExpressionAst))
{
return(false);
}
var type = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
if (type == null)
{
return(false);
}
var member = memberExpressionAst.Member as StringConstantExpressionAst;
if (member == null)
{
return(false);
}
var memberInfo = type.GetMember(member.Value, MemberTypes.Field,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
if (memberInfo.Length != 1)
{
return(false);
}
return((((FieldInfo)memberInfo[0]).Attributes & FieldAttributes.Literal) != 0);
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
if (!memberExpressionAst.Static || !(memberExpressionAst.Expression is TypeExpressionAst))
{
return(false);
}
Type reflectionType = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
if (reflectionType == null)
{
return(false);
}
StringConstantExpressionAst member = memberExpressionAst.Member as StringConstantExpressionAst;
if (member == null)
{
return(false);
}
MemberInfo[] infoArray = reflectionType.GetMember(member.Value, MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase);
if (infoArray.Length != 1)
{
return(false);
}
return((((FieldInfo)infoArray[0]).Attributes & FieldAttributes.Literal) != FieldAttributes.PrivateScope);
}
public System.Object VisitMemberExpression(System.Management.Automation.Language.MemberExpressionAst memberExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(memberExpressionAst.Extent);
ExpressionAst mappedExpression = _VisitExpression(memberExpressionAst.Expression);
CommandElementAst mappedMember = _VisitCommandElement(memberExpressionAst.Member);
return(new MemberExpressionAst(mappedExtent, mappedExpression, mappedMember, memberExpressionAst.Static));
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
CheckIsConstant(memberExpressionAst, "Caller to verify ast is constant");
var type = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
var member = ((StringConstantExpressionAst)memberExpressionAst.Member).Value;
var memberInfo = type.GetMember(member, MemberTypes.Field,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
return(((FieldInfo)memberInfo[0]).GetValue(null));
}
private static VariableExpressionAst ExtractUsingVariableImpl(ExpressionAst expression)
{
VariableExpressionAst subExpression;
UsingExpressionAst ast = expression as UsingExpressionAst;
if (ast != null)
{
subExpression = ast.SubExpression as VariableExpressionAst;
if (subExpression != null)
{
return(subExpression);
}
return(ExtractUsingVariableImpl(ast.SubExpression));
}
IndexExpressionAst ast3 = expression as IndexExpressionAst;
if (ast3 != null)
{
subExpression = ast3.Target as VariableExpressionAst;
if (subExpression != null)
{
return(subExpression);
}
return(ExtractUsingVariableImpl(ast3.Target));
}
MemberExpressionAst ast4 = expression as MemberExpressionAst;
if (ast4 == null)
{
return(null);
}
subExpression = ast4.Expression as VariableExpressionAst;
if (subExpression != null)
{
return(subExpression);
}
return(ExtractUsingVariableImpl(ast4.Expression));
}
private void SetMemberExpressionValue(MemberExpressionAst memberExpressionAst, object value)
{
string memberName;
var psobj = EvaluateAsPSObject(memberExpressionAst.Expression);
var unwraped = PSObject.Unwrap(psobj);
var memberNameObj = EvaluateAst(memberExpressionAst.Member, false);
// check for Hashtable first
if (unwraped is Hashtable && memberNameObj != null &&
!_hashtableAccessibleMembers.Contains(memberNameObj.ToString()))
{
((Hashtable) unwraped)[memberNameObj] = value;
return;
}
// else it's a PSObject
var member = GetPSObjectMember(psobj, memberNameObj, memberExpressionAst.Static, out memberName);
if (member == null)
{
throw new PSArgumentNullException(String.Format("Member '{0}' to be assigned is null", memberName));
}
member.Value = value;
}
public virtual AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return AstVisitAction.Continue;
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
var expression = memberExpressionAst.Expression;
ObjectInfo objectInfo = GetObjectInfo(expression);
if (memberExpressionAst.Member is StringConstantExpressionAst)
{
object result = null;
var name = (memberExpressionAst.Member as StringConstantExpressionAst).Value;
var memberInfo = objectInfo.GetMember(name, memberExpressionAst.Static);
if (memberInfo != null)
{
switch (memberInfo.MemberType)
{
case MemberTypes.Field:
result = ((FieldInfo)memberInfo).GetValue(objectInfo.Object);
break;
case MemberTypes.Property:
result = ((PropertyInfo)memberInfo).GetValue(objectInfo.Object, null);
break;
default:
throw new NotImplementedException(this.ToString());
}
}
_pipelineCommandRuntime.WriteObject(result);
return AstVisitAction.SkipChildren;
}
throw new NotImplementedException(this.ToString());
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
CheckMemberAccess(memberExpressionAst);
return AstVisitAction.Continue;
}
/// <summary/>
public virtual object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return _decorated.VisitMemberExpression(memberExpressionAst);
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
throw new UnexpectedElementException();
}
internal SettableMemberExpression(MemberExpressionAst expressionAst, ExecutionVisitor currentExecution)
: base(currentExecution)
{
_expressionAst = expressionAst;
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
CheckIsConstant(memberExpressionAst, "Caller to verify ast is constant");
var type = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
var member = ((StringConstantExpressionAst)memberExpressionAst.Member).Value;
var memberInfo = type.GetMember(member, MemberTypes.Field,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
return ((FieldInfo)memberInfo[0]).GetValue(null);
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
if (!memberExpressionAst.Static || !(memberExpressionAst.Expression is TypeExpressionAst))
{
return false;
}
var type = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
if (type == null)
{
return false;
}
var member = memberExpressionAst.Member as StringConstantExpressionAst;
if (member == null)
{
return false;
}
var memberInfo = type.GetMember(member.Value, MemberTypes.Field,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
if (memberInfo.Length != 1)
{
return false;
}
return (((FieldInfo)memberInfo[0]).Attributes & FieldAttributes.Literal) != 0;
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
throw new NotImplementedException(); //VisitMemberExpression(memberExpressionAst);
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return (!((bool) memberExpressionAst.Expression.Accept(this)) ? ((object) 0) : ((object) ((bool) memberExpressionAst.Member.Accept(this))));
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst ast)
{
return this.Check(ast);
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
this.ReportError(memberExpressionAst, () => ParserStrings.PropertyReferenceNotSupportedInDataSection, new object[0]);
return(AstVisitAction.Continue);
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst ast)
{
return(Check(ast));
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return(false);
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return false;
}
/// <summary/> public virtual AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst) => DefaultVisit(memberExpressionAst);
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
throw PSTraceSource.NewArgumentException("ast");
}
/// <summary>
/// Visit Member Expression
/// </summary>
/// <param name="memberExpressionAst"></param>
/// <returns></returns>
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
if (memberExpressionAst == null) return null;
memberExpressionAst.Expression.Visit(this.Decorator);
memberExpressionAst.Member.Visit(this.Decorator);
return null;
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
// Getting a static member is much simpler because we can ignore instance
// and type table members and we only have one adapter - .Net. So we'll
// avoid a dynamic expression if possible.
if (memberExpressionAst.Static && (memberExpressionAst.Expression is TypeExpressionAst))
{
var type = ((TypeExpressionAst)memberExpressionAst.Expression).TypeName.GetReflectionType();
if (type != null && !type.GetTypeInfo().IsGenericTypeDefinition)
{
var member = memberExpressionAst.Member as StringConstantExpressionAst;
if (member != null)
{
// We skip Methods because the adapter wraps them in a PSMethod and it's not a common scenario.
var memberInfo = type.GetMember(member.Value, MemberTypes.Field | MemberTypes.Property,
BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Static |
BindingFlags.FlattenHierarchy);
if (memberInfo.Length == 1)
{
var propertyInfo = memberInfo[0] as PropertyInfo;
if (propertyInfo != null)
{
if (propertyInfo.CanRead)
{
return Expression.Property(null, propertyInfo);
}
// else let the dynamic site generate the error - this is rare anyway
}
else
{
return Expression.Field(null, (FieldInfo)memberInfo[0]);
}
}
}
}
}
var target = CompileExpressionOperand(memberExpressionAst.Expression);
var memberNameAst = memberExpressionAst.Member as StringConstantExpressionAst;
if (memberNameAst != null)
{
string name = memberNameAst.Value;
return DynamicExpression.Dynamic(PSGetMemberBinder.Get(name, _memberFunctionType, memberExpressionAst.Static), typeof(object), target);
}
var memberNameExpr = Compile(memberExpressionAst.Member);
return DynamicExpression.Dynamic(PSGetDynamicMemberBinder.Get(_memberFunctionType, memberExpressionAst.Static), typeof(object), target, memberNameExpr);
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
_pipelineCommandRuntime.WriteObject(new SettableMemberExpression(memberExpressionAst, this).GetValue());
return AstVisitAction.SkipChildren;
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
this.ReportError(memberExpressionAst, () => ParserStrings.PropertyReferenceNotSupportedInDataSection, new object[0]);
return AstVisitAction.Continue;
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
string memberName;
var psobj = EvaluateAsPSObject(memberExpressionAst.Expression);
var unwraped = PSObject.Unwrap(psobj);
var memberNameObj = EvaluateAst(memberExpressionAst.Member, false);
// check for Hastable first
if (unwraped is Hashtable && memberNameObj != null &&
!_hashtableAccessibleMembers.Contains(memberNameObj.ToString()))
{
var hashtable = (Hashtable)unwraped;
_pipelineCommandRuntime.WriteObject(hashtable[memberNameObj]);
}
else // otherwise a PSObject
{
var member = GetPSObjectMember(psobj, memberNameObj, memberExpressionAst.Static, out memberName);
var value = (member == null) ? null : PSObject.AsPSObject(member.Value);
_pipelineCommandRuntime.WriteObject(value);
}
return AstVisitAction.SkipChildren;
}
private PSMemberInfo GetPSObjectMemberFromMemberExpression(MemberExpressionAst memberExpressionAst, out string memberName)
{
var psobj = EvaluateAsPSObject(memberExpressionAst.Expression);
var memberNameObj = EvaluateAst(memberExpressionAst.Member, false);
if (memberNameObj == null)
{
throw new PSArgumentNullException("Member name evaluates to null");
}
memberName = memberNameObj.ToString();
if (memberExpressionAst.Static)
{
return psobj.StaticMembers[memberName];
}
return psobj.Members[memberName];
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
var expression = memberExpressionAst.Expression;
Type type;
object obj;
if (expression is TypeExpressionAst)
{
obj = null;
type = ((TypeExpressionAst)expression).TypeName.GetReflectionType();
}
else
{
obj = EvaluateAst(expression);
if (obj is PSObject)
{
obj = ((PSObject)obj).BaseObject;
}
type = obj.GetType();
}
if (memberExpressionAst.Member is StringConstantExpressionAst)
{
object result = null;
var name = (memberExpressionAst.Member as StringConstantExpressionAst).Value;
BindingFlags bindingFlags = BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static;
// TODO: Single() is a problem for overloaded methods
var memberInfo = type.GetMember(name, bindingFlags).Single();
if (memberInfo != null)
{
switch (memberInfo.MemberType)
{
case MemberTypes.Field:
result = ((FieldInfo)memberInfo).GetValue(obj);
break;
case MemberTypes.Property:
result = ((PropertyInfo)memberInfo).GetValue(obj, null);
break;
default:
throw new NotImplementedException(this.ToString());
}
}
_pipelineCommandRuntime.WriteObject(result);
return AstVisitAction.SkipChildren;
}
throw new NotImplementedException(this.ToString());
}
private void SetMemberExpressionValue(MemberExpressionAst memberExpressionAst, object value)
{
string memberName;
var member = GetPSObjectMemberFromMemberExpression(memberExpressionAst, out memberName);
if (member == null)
{
throw new PSArgumentNullException(String.Format("Member '{0}' to be assigned is null", memberName));
}
member.Value = value;
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
memberExpressionAst.Expression.Accept(this);
memberExpressionAst.Member.Accept(this);
return(null);
}
public override AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
string memberName;
var member = GetPSObjectMemberFromMemberExpression(memberExpressionAst, out memberName);
var value = PSObject.AsPSObject((member == null) ? null : member.Value);
_pipelineCommandRuntime.WriteObject(value);
return AstVisitAction.SkipChildren;
}
/// <summary/>
public virtual object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return(null);
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
memberExpressionAst.Expression.Accept(this);
memberExpressionAst.Member.Accept(this);
return null;
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
if (!memberExpressionAst.Static || !(memberExpressionAst.Expression is TypeExpressionAst))
{
return false;
}
Type reflectionType = ((TypeExpressionAst) memberExpressionAst.Expression).TypeName.GetReflectionType();
if (reflectionType == null)
{
return false;
}
StringConstantExpressionAst member = memberExpressionAst.Member as StringConstantExpressionAst;
if (member == null)
{
return false;
}
MemberInfo[] infoArray = reflectionType.GetMember(member.Value, MemberTypes.Field, BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase);
if (infoArray.Length != 1)
{
return false;
}
return ((((FieldInfo) infoArray[0]).Attributes & FieldAttributes.Literal) != FieldAttributes.PrivateScope);
}
internal static Type GetTypeFromMemberExpressionAst(MemberExpressionAst memAst, VariableAnalysisDetails analysis, TypeDefinitionAst psClass)
#endif
{
if (memAst != null && memAst.Expression is VariableExpressionAst && memAst.Member is StringConstantExpressionAst
&& !String.Equals((memAst.Expression as VariableExpressionAst).VariablePath.UserPath, "this", StringComparison.OrdinalIgnoreCase))
{
string fieldName = (memAst.Member as StringConstantExpressionAst).Value;
#if !PSV3
if (psClass == null && analysis.Constant == SpecialVars.ThisVariable)
{
psClass = AssignmentTarget.FindClassAncestor(memAst);
}
if (psClass != null)
{
Type typeFromClass = AssignmentTarget.GetTypeFromClass(psClass, memAst);
{
if (typeFromClass != null)
{
return typeFromClass;
}
}
}
#endif
// If the type is not a ps class or there are some types of the same name.
if (analysis != null && analysis.Type != null && analysis.Type != typeof(object)
&& analysis.Type != typeof(Unreached) && analysis.Type != typeof(Undetermined))
{
if (memAst is InvokeMemberExpressionAst)
{
return AssignmentTarget.GetTypeFromInvokeMemberAst(analysis.Type, memAst as InvokeMemberExpressionAst, fieldName, false);
}
else
{
return AssignmentTarget.GetPropertyOrFieldTypeFromMemberExpressionAst(analysis.Type, fieldName);
}
}
}
return null;
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
throw PSTraceSource.NewArgumentException("ast");
}
/// <summary>
/// Given a memberAst, try to return the type of the expression. This assumes that the memberAst is of the form
/// [Type]::method/field or $this.method/field
/// </summary>
/// <param name="memberAst"></param>
/// <returns></returns>
internal static Type GetTypeFromMemberExpressionAst(MemberExpressionAst memberAst)
{
Type result = null;
StringConstantExpressionAst stringAst = memberAst.Member as StringConstantExpressionAst;
if (stringAst == null)
{
return result;
}
if (memberAst is InvokeMemberExpressionAst)
{
#region RHS is InvokeMemberExpressionAst
InvokeMemberExpressionAst imeAst = memberAst as InvokeMemberExpressionAst;
if (imeAst.Expression is TypeExpressionAst)
{
string methodName = stringAst.Value;
Type type = (imeAst.Expression as TypeExpressionAst).TypeName.GetReflectionType();
if (String.Equals(methodName, "new", StringComparison.OrdinalIgnoreCase))
{
result = type;
}
else if (type != null && type != typeof(object))
{
// isStatic is true
result = GetTypeFromInvokeMemberAst(type, imeAst, methodName, true);
}
#if !PSV3
else
{
// Check for classes
TypeDefinitionAst psClass = FindClass(memberAst, (imeAst.Expression as TypeExpressionAst).TypeName.FullName);
if (psClass != null)
{
MemberAst funcMemberAst = psClass.Members.FirstOrDefault(item =>
item is FunctionMemberAst && (item as FunctionMemberAst).IsStatic
&& String.Equals(item.Name, methodName, StringComparison.OrdinalIgnoreCase));
if (funcMemberAst != null)
{
result = (funcMemberAst as FunctionMemberAst).ReturnType.TypeName.GetReflectionType();
}
}
}
#endif
}
#endregion
}
else
{
#region RHS is MemberExpressionAst
//syntax like $a=[System.AppDomain]::CurrentDomain
string fieldName = stringAst.Value;
if (memberAst.Expression is TypeExpressionAst)
{
Type expressionType = (memberAst.Expression is TypeExpressionAst) ? (memberAst.Expression as TypeExpressionAst).TypeName.GetReflectionType() : null;
if (expressionType != null)
{
result = GetPropertyOrFieldTypeFromMemberExpressionAst(expressionType, fieldName);
}
#if !PSV3
else
{
// check for class type
TypeDefinitionAst psClass = FindClass(memberAst, (memberAst.Expression as TypeExpressionAst).TypeName.FullName);
if (psClass != null)
{
MemberAst memAst = psClass.Members.FirstOrDefault(item => String.Equals(item.Name, fieldName, StringComparison.OrdinalIgnoreCase));
if (memAst != null && memAst is PropertyMemberAst && (memAst as PropertyMemberAst).IsStatic)
{
result = (memAst as PropertyMemberAst).PropertyType.TypeName.GetReflectionType();
}
}
}
#endif
}
#endregion
}
if (result != null)
{
return result;
}
#region RHS contains $this variable
// For the case where variable is $this
if (memberAst.Expression is VariableExpressionAst
&& String.Equals((memberAst.Expression as VariableExpressionAst).VariablePath.UserPath, "this", StringComparison.OrdinalIgnoreCase))
{
#if !PSV3
// Check that we are in a class
TypeDefinitionAst psClass = FindClassAncestor(memberAst);
// Is static is false for this case
result = GetTypeFromClass(psClass, memberAst);
#endif
}
return result;
#endregion
}
/// <summary/>
public virtual AstVisitAction VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
return(AstVisitAction.Continue);
}
/// <summary>
/// Get the type for memberexpressionast assuming that the variable is a class
/// </summary>
/// <param name="psClass"></param>
/// <param name="memberExpressionAst"></param>
/// <returns></returns>
internal static Type GetTypeFromClass(TypeDefinitionAst psClass, MemberExpressionAst memberExpressionAst)
{
Type result = null;
if (psClass != null)
{
MemberAst memAst = psClass.Members.FirstOrDefault(item => String.Equals(item.Name, (memberExpressionAst.Member as StringConstantExpressionAst).Value, StringComparison.OrdinalIgnoreCase));
if (memAst != null)
{
if (memAst is PropertyMemberAst)
{
result = (memAst as PropertyMemberAst).PropertyType.TypeName.GetReflectionType();
}
else if (memAst is FunctionMemberAst)
{
result = (memAst as FunctionMemberAst).ReturnType.TypeName.GetReflectionType();
}
}
}
return result;
}
/// <summary>
/// Get the type from member expression ast in the form of $variable.field/method
/// type is the type of variable. Class is the class that matches the type
/// </summary>
/// <param name="analysis"></param>
/// <param name="memAst"></param>
/// <param name="psClass"></param>
/// <returns></returns>
#if PSV3
internal static Type GetTypeFromMemberExpressionAst(MemberExpressionAst memAst, VariableAnalysisDetails analysis)
private void CheckMemberAccess(MemberExpressionAst ast)
{
// If the member access is not constant, it may be considered suspicious
if (!(ast.Member is ConstantExpressionAst))
{
MarkAstParentsAsSuspicious(ast);
}
TypeExpressionAst typeExpression = ast.Expression as TypeExpressionAst;
// If this is static access on a variable, it may be suspicious
if (ast.Static && (typeExpression == null))
{
MarkAstParentsAsSuspicious(ast);
}
}
