{

/// <summary>

/// No runtime use is allowed.

/// </summary>

None = 0,

/// <summary>

/// Use of SafeExprEvaluator visitor is allowed.

/// </summary>

AllowSafeEval = 1,

{

/// <summary>

/// Infers the type that the result of executing a statement would have without using runtime safe eval.

/// </summary>

/// <param name="ast">The ast to infer the type from.</param>

/// <returns>List of inferred typenames.</returns>

public static IList<PSTypeName> InferTypeOf(Ast ast)

{

return InferTypeOf(ast, TypeInferenceRuntimePermissions.None);

}

/// <summary>

/// Infers the type that the result of executing a statement would have.

/// </summary>

/// <param name="ast">The ast to infer the type from.</param>

/// <param name="evalPermissions">The runtime usage permissions allowed during type inference.</param>

/// <returns>List of inferred typenames.</returns>

public static IList<PSTypeName> InferTypeOf(Ast ast, TypeInferenceRuntimePermissions evalPermissions)

{

return InferTypeOf(ast, PowerShell.Create(RunspaceMode.CurrentRunspace), evalPermissions);

}

/// <summary>

/// Infers the type that the result of executing a statement would have without using runtime safe eval.

/// </summary>

/// <param name="ast">The ast to infer the type from.</param>

/// <param name="powerShell">The instance of powershell to use for expression evaluation needed for type inference.</param>

/// <returns>List of inferred typenames.</returns>

public static IList<PSTypeName> InferTypeOf(Ast ast, PowerShell powerShell)

{

return InferTypeOf(ast, powerShell, TypeInferenceRuntimePermissions.None);

}

/// <summary>

/// Infers the type that the result of executing a statement would have.

/// </summary>

/// <param name="ast">The ast to infer the type from.</param>

/// <param name="powerShell">The instance of powershell to user for expression evaluation needed for type inference.</param>

/// <param name="evalPersmissions">The runtime usage permissions allowed during type inference.</param>

/// <returns>List of inferred typenames.</returns>

public static IList<PSTypeName> InferTypeOf(Ast ast, PowerShell powerShell, TypeInferenceRuntimePermissions evalPersmissions)

{

var context = new TypeInferenceContext(powerShell);

return InferTypeOf(ast, context, evalPersmissions);

}

/// <summary>

/// Infers the type that the result of executing a statement would have.

/// </summary>

/// <param name="ast">The ast to infer the type from.</param>

/// <param name="context">The current type inference context.</param>

/// <param name="evalPersmissions">The runtime usage permissions allowed during type inference.</param>

/// <returns>List of inferred typenames.</returns>

internal static IList<PSTypeName> InferTypeOf(

Ast ast,

TypeInferenceContext context,

TypeInferenceRuntimePermissions evalPersmissions = TypeInferenceRuntimePermissions.None)

{

var originalRuntimePermissions = context.RuntimePermissions;

try

{

context.RuntimePermissions = evalPersmissions;

return context.InferType(ast, new TypeInferenceVisitor(context)).Distinct(new PSTypeNameComparer()).ToList();

}

finally

{

context.RuntimePermissions = originalRuntimePermissions;

}

}

{

public bool Equals(PSTypeName x, PSTypeName y)

{

return x.Name.Equals(y.Name);

}

public int GetHashCode(PSTypeName obj)

{

return obj.Name.GetHashCode();

}

{

public static readonly PSTypeName[] EmptyPSTypeNameArray = Array.Empty<PSTypeName>();

private readonly PowerShell _powerShell;

public TypeInferenceContext() : this(PowerShell.Create(RunspaceMode.CurrentRunspace))

{

}

/// <summary>

/// Initializes a new instance of the <see cref="TypeInferenceContext"/> class.

/// The powerShell instance passed need to have a non null Runspace.

/// </summary>

/// <param name="powerShell">The instance of powershell to use for expression evaluation needed for type inference.</param>

public TypeInferenceContext(PowerShell powerShell)

{

Diagnostics.Assert(powerShell.Runspace != null, "Callers are required to ensure we have a runspace");

_powerShell = powerShell;

Helper = new PowerShellExecutionHelper(powerShell);

}

// used to infer types in script properties attached to an object,

// to be able to determine the type of $this in the scripts properties

public PSTypeName CurrentThisType { get; set; }

public TypeDefinitionAst CurrentTypeDefinitionAst { get; set; }

public TypeInferenceRuntimePermissions RuntimePermissions { get; set; }

internal PowerShellExecutionHelper Helper { get; }

internal ExecutionContext ExecutionContext => _powerShell.Runspace.ExecutionContext;

public bool TryGetRepresentativeTypeNameFromExpressionSafeEval(ExpressionAst expression, out PSTypeName typeName)

{

typeName = null;

if (RuntimePermissions != TypeInferenceRuntimePermissions.AllowSafeEval)

{

return false;

}

return expression != null &&

SafeExprEvaluator.TrySafeEval(expression, ExecutionContext, out var value) &&

TryGetRepresentativeTypeNameFromValue(value, out typeName);

}

internal IList<object> GetMembersByInferredType(PSTypeName typename, bool isStatic, Func<object, bool> filter)

{

List<object> results = new List<object>();

Func<object, bool> filterToCall = filter;

if (typename is PSSyntheticTypeName synthetic)

{

foreach (var mem in synthetic.Members)

{

results.Add(new PSInferredProperty(mem.Name, mem.PSTypeName));

}

}

if (typename.Type != null)

{

AddMembersByInferredTypesClrType(typename, isStatic, filter, filterToCall, results);

}

else if (typename.TypeDefinitionAst != null)

{

AddMembersByInferredTypeDefinitionAst(typename, isStatic, filter, filterToCall, results);

}

else

{

// Look in the type table first.

if (!isStatic)

{

var consolidatedString = new ConsolidatedString(new[] { typename.Name });

results.AddRange(ExecutionContext.TypeTable.GetMembers<PSMemberInfo>(consolidatedString));

}

AddMembersByInferredTypeCimType(typename, results, filterToCall);

}

return results;

}

internal void AddMembersByInferredTypesClrType(PSTypeName typename, bool isStatic, Func<object, bool> filter, Func<object, bool> filterToCall, List<object> results)

{

if (CurrentTypeDefinitionAst == null || CurrentTypeDefinitionAst.Type != typename.Type)

{

if (filterToCall == null)

{

filterToCall = o => !IsMemberHidden(o);

}

else

{

filterToCall = o => !IsMemberHidden(o) && filter(o);

}

}

IEnumerable<Type> elementTypes;

if (typename.Type.IsArray)

{

elementTypes = new[] { typename.Type.GetElementType() };

}

else

{

var elementList = new List<Type>();

foreach (var t in typename.Type.GetInterfaces())

{

if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>))

{

elementList.Add(t);

}

}

elementTypes = elementList;

}

foreach (var type in elementTypes.Prepend(typename.Type))

{

// Look in the type table first.

if (!isStatic)

{

var consolidatedString = DotNetAdapter.GetInternedTypeNameHierarchy(type);

results.AddRange(ExecutionContext.TypeTable.GetMembers<PSMemberInfo>(consolidatedString));

}

var members = isStatic

? PSObject.DotNetStaticAdapter.BaseGetMembers<PSMemberInfo>(type)

: PSObject.DotNetInstanceAdapter.GetPropertiesAndMethods(type, false);

if (filterToCall != null)

{

foreach (var member in members)

{

if (filterToCall(member))

{

results.Add(member);

}

}

}

else

{

results.AddRange(members);

}

}

}

internal void AddMembersByInferredTypeDefinitionAst(

PSTypeName typename,

bool isStatic,

Func<object, bool> filter,

Func<object, bool> filterToCall,

List<object> results)

{

if (CurrentTypeDefinitionAst != typename.TypeDefinitionAst)

{

if (filterToCall == null)

{

filterToCall = o => !IsMemberHidden(o);

}

else

{

filterToCall = o => !IsMemberHidden(o) && filter(o);

}

}

bool foundConstructor = false;

foreach (var member in typename.TypeDefinitionAst.Members)

{

bool add;

if (member is PropertyMemberAst propertyMember)

{

add = propertyMember.IsStatic == isStatic;

}

else

{

var functionMember = (FunctionMemberAst)member;

add = (functionMember.IsConstructor && isStatic) || (!functionMember.IsConstructor && functionMember.IsStatic == isStatic);

foundConstructor |= functionMember.IsConstructor;

}

if (filterToCall != null && add)

{

add = filterToCall(member);

}

if (add)

{

results.Add(member);

}

}

// iterate through bases/interfaces

foreach (var baseType in typename.TypeDefinitionAst.BaseTypes)

{

if (!(baseType.TypeName is TypeName baseTypeName))

{

continue;

}

var baseTypeDefinitionAst = baseTypeName._typeDefinitionAst;

if (baseTypeDefinitionAst is null)

{

var baseReflectionType = baseTypeName.GetReflectionType();

if (baseReflectionType is not null)

{

results.AddRange(GetMembersByInferredType(new PSTypeName(baseReflectionType), isStatic, filterToCall));

}

}

else

{

results.AddRange(GetMembersByInferredType(new PSTypeName(baseTypeDefinitionAst), isStatic, filterToCall));

}

}

// Add stuff from our base class System.Object.

if (isStatic)

{

// Don't add base class constructors

if (filter == null)

{

filterToCall = o => !IsConstructor(o);

}

else

{

filterToCall = o => !IsConstructor(o) && filter(o);

}

if (!foundConstructor)

{

results.Add(

new CompilerGeneratedMemberFunctionAst(

PositionUtilities.EmptyExtent,

typename.TypeDefinitionAst,

SpecialMemberFunctionType.DefaultConstructor));

}

}

else

{

// Reset the filter because the recursive call will add IsHidden back if necessary.

filterToCall = filter;

}

PSTypeName baseMembersType;

if (typename.TypeDefinitionAst.IsEnum)

{

if (!isStatic)

{

results.Add(new PSInferredProperty("value__", new PSTypeName(typeof(int))));

}

baseMembersType = new PSTypeName(typeof(Enum));

}

else

{

baseMembersType = new PSTypeName(typeof(object));

}

results.AddRange(GetMembersByInferredType(baseMembersType, isStatic, filterToCall));

}

internal void AddMembersByInferredTypeCimType(PSTypeName typename, List<object> results, Func<object, bool> filterToCall)

{

if (ParseCimCommandsTypeName(typename, out var cimNamespace, out var className))

{

var powerShellExecutionHelper = Helper;

powerShellExecutionHelper.AddCommandWithPreferenceSetting("CimCmdlets\\Get-CimClass")

.AddParameter("Namespace", cimNamespace)

.AddParameter("Class", className);

var classes = powerShellExecutionHelper.ExecuteCurrentPowerShell(out _);

var cimClasses = new List<CimClass>();

foreach (var c in classes)

{

if (PSObject.Base(c) is CimClass cc)

{

cimClasses.Add(cc);

}

}

foreach (var cimClass in cimClasses)

{

if (filterToCall == null)

{

results.AddRange(cimClass.CimClassProperties);

}

else

{

foreach (var prop in cimClass.CimClassProperties)

{

if (filterToCall(prop))

{

results.Add(prop);

}

}

}

}

}

}

internal IEnumerable<PSTypeName> InferType(Ast ast, TypeInferenceVisitor visitor)

{

var res = ast.Accept(visitor);

Diagnostics.Assert(res != null, "Fix visit methods to not return null");

return (IEnumerable<PSTypeName>)res;

}

private static bool TryGetRepresentativeTypeNameFromValue(object value, out PSTypeName type)

{

type = null;

if (value != null)

{

if (value is IList list

&& list.Count > 0)

{

value = list[0];

}

value = PSObject.Base(value);

if (value != null)

{

var typeObject = value.GetType();

if (typeObject.FullName.Equals("System.Management.Automation.PSObject", StringComparison.Ordinal))

{

var psobjectPropertyList = new List<PSMemberNameAndType>();

foreach (var property in ((PSObject)value).Properties)

{

if (property.IsHidden)

{

continue;

}

var propertyTypeName = new PSTypeName(property.TypeNameOfValue);

psobjectPropertyList.Add(new PSMemberNameAndType(property.Name, propertyTypeName, property.Value));

}

type = PSSyntheticTypeName.Create(typeObject, psobjectPropertyList);

}

else

{

type = new PSTypeName(typeObject);

}

return true;

}

}

return false;

}

internal static bool ParseCimCommandsTypeName(PSTypeName typename, out string cimNamespace, out string className)

{

cimNamespace = null;

className = null;

if (typename == null)

{

return false;

}

if (typename.Type != null)

{

return false;

}

var match = Regex.Match(typename.Name, "(?<NetTypeName>.*)#(?<CimNamespace>.*)[/\\\\](?<CimClassName>.*)");

if (!match.Success)

{

return false;

}

if (!match.Groups["NetTypeName"].Value.EqualsOrdinalIgnoreCase(typeof(CimInstance).FullName))

{

return false;

}

cimNamespace = match.Groups["CimNamespace"].Value;

className = match.Groups["CimClassName"].Value;

return true;

}

private static bool IsMemberHidden(object member)

{

switch (member)

{

case PSMemberInfo psMemberInfo:

return psMemberInfo.IsHidden;

case MemberInfo memberInfo:

return memberInfo.GetCustomAttributes(typeof(HiddenAttribute), false).Length != 0;

case PropertyMemberAst propertyMember:

return propertyMember.IsHidden;

case FunctionMemberAst functionMember:

return functionMember.IsHidden;

}

return false;

}

private static bool IsConstructor(object member)

{

var psMethod = member as PSMethod;

var methodCacheEntry = psMethod?.adapterData as DotNetAdapter.MethodCacheEntry;

return methodCacheEntry != null && methodCacheEntry.methodInformationStructures[0].method.IsConstructor;

}

{

private readonly TypeInferenceContext _context;

private static readonly PSTypeName StringPSTypeName = new PSTypeName(typeof(string));

public TypeInferenceVisitor(TypeInferenceContext context)

{

_context = context;

}

private IEnumerable<PSTypeName> InferTypes(Ast ast)

{

return _context.InferType(ast, this);

}

object ICustomAstVisitor.VisitTypeExpression(TypeExpressionAst typeExpressionAst)

{

return new[] { new PSTypeName(typeExpressionAst.StaticType) };

}

object ICustomAstVisitor.VisitMemberExpression(MemberExpressionAst memberExpressionAst)

{

return InferTypesFrom(memberExpressionAst);

}

object ICustomAstVisitor.VisitInvokeMemberExpression(InvokeMemberExpressionAst invokeMemberExpressionAst)

{

return InferTypesFrom(invokeMemberExpressionAst);

}

object ICustomAstVisitor.VisitArrayExpression(ArrayExpressionAst arrayExpressionAst)

{

if (arrayExpressionAst.SubExpression.Statements.Count == 0)

{

return new[] { new PSTypeName(typeof(object[])) };

}

return new[] { GetArrayType(InferTypes(arrayExpressionAst.SubExpression)) };

}

object ICustomAstVisitor.VisitArrayLiteral(ArrayLiteralAst arrayLiteralAst)

{

var inferredElementTypes = new List<PSTypeName>();

foreach (ExpressionAst expression in arrayLiteralAst.Elements)

{

inferredElementTypes.AddRange(InferTypes(expression));

}

return new[] { GetArrayType(inferredElementTypes) };

}

object ICustomAstVisitor.VisitHashtable(HashtableAst hashtableAst)

{

if (hashtableAst.KeyValuePairs.Count > 0)

{

var properties = new List<PSMemberNameAndType>();

void AddInferredTypes(Ast ast, string keyName)

{

bool foundAnyTypes = false;

foreach (PSTypeName item in InferTypes(ast))

{

foundAnyTypes = true;

properties.Add(new PSMemberNameAndType(keyName, item));

}

if (!foundAnyTypes)

{

properties.Add(new PSMemberNameAndType(keyName, new PSTypeName("System.Object")));

}

}

foreach (var kv in hashtableAst.KeyValuePairs)

{

string name = null;

if (kv.Item1 is StringConstantExpressionAst stringConstantExpressionAst)

{

name = stringConstantExpressionAst.Value;

}

else if (kv.Item1 is ConstantExpressionAst constantExpressionAst)

{

name = constantExpressionAst.Value.ToString();

}

else if (SafeExprEvaluator.TrySafeEval(kv.Item1, _context.ExecutionContext, out object nameValue))

{

name = nameValue.ToString();

}

if (name is not null)

{

if (kv.Item2 is PipelineAst pipelineAst && pipelineAst.GetPureExpression() is ExpressionAst expression)

{

object value;

if (expression is ConstantExpressionAst constant)

{

value = constant.Value;

}

else

{

_ = SafeExprEvaluator.TrySafeEval(expression, _context.ExecutionContext, out value);

}

if (value is null)

{

AddInferredTypes(expression, name);

continue;

}

PSTypeName valueType = new(value.GetType());

properties.Add(new PSMemberNameAndType(name, valueType, value));

}

else

{

AddInferredTypes(kv.Item2, name);

}

}

}

return new[] { PSSyntheticTypeName.Create(typeof(Hashtable), properties) };

}

return new[] { new PSTypeName(typeof(Hashtable)) };

}

object ICustomAstVisitor.VisitScriptBlockExpression(ScriptBlockExpressionAst scriptBlockExpressionAst)

{

return new[] { new PSTypeName(typeof(ScriptBlock)) };

}

object ICustomAstVisitor.VisitParenExpression(ParenExpressionAst parenExpressionAst)

{

return parenExpressionAst.Pipeline.Accept(this);

}

object ICustomAstVisitor.VisitExpandableStringExpression(ExpandableStringExpressionAst expandableStringExpressionAst)

{

return new[] { StringPSTypeName };

}

object ICustomAstVisitor.VisitIndexExpression(IndexExpressionAst indexExpressionAst)

{

return InferTypeFrom(indexExpressionAst);

}

object ICustomAstVisitor.VisitAttributedExpression(AttributedExpressionAst attributedExpressionAst)

{

return attributedExpressionAst.Child.Accept(this);

}

object ICustomAstVisitor.VisitBlockStatement(BlockStatementAst blockStatementAst)

{

return blockStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitUsingExpression(UsingExpressionAst usingExpressionAst)

{

return usingExpressionAst.SubExpression.Accept(this);

}

object ICustomAstVisitor.VisitVariableExpression(VariableExpressionAst ast)

{

var inferredTypes = new List<PSTypeName>();

InferTypeFrom(ast, inferredTypes);

return inferredTypes;

}

object ICustomAstVisitor.VisitMergingRedirection(MergingRedirectionAst mergingRedirectionAst)

{

return TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitBinaryExpression(BinaryExpressionAst binaryExpressionAst)

{

// TODO: Handle other kinds of expressions on the right side.

if (binaryExpressionAst.Operator == TokenKind.As && binaryExpressionAst.Right is TypeExpressionAst typeExpression)

{

var type = typeExpression.TypeName.GetReflectionType();

var psTypeName = type != null ? new PSTypeName(type) : new PSTypeName(typeExpression.TypeName.FullName);

return new[] { psTypeName };

}

return InferTypes(binaryExpressionAst.Left);

}

object ICustomAstVisitor.VisitUnaryExpression(UnaryExpressionAst unaryExpressionAst)

{

var tokenKind = unaryExpressionAst.TokenKind;

return (tokenKind == TokenKind.Not || tokenKind == TokenKind.Exclaim)

? BinaryExpressionAst.BoolTypeNameArray

: unaryExpressionAst.Child.Accept(this);

}

object ICustomAstVisitor.VisitConvertExpression(ConvertExpressionAst convertExpressionAst)

{

// The reflection type of PSCustomObject is PSObject, so this covers both the

// [PSObject] @{ Key = "Value" } and the [PSCustomObject] @{ Key = "Value" } case.

var type = convertExpressionAst.Type.TypeName.GetReflectionType();

if (type is null && convertExpressionAst.Type.TypeName is TypeName unavailableType && unavailableType._typeDefinitionAst is not null)

{

return new[] { new PSTypeName(unavailableType._typeDefinitionAst) };

}

if (type == typeof(PSObject) && convertExpressionAst.Child is HashtableAst hashtableAst)

{

if (InferTypes(hashtableAst).FirstOrDefault() is PSSyntheticTypeName syntheticTypeName)

{

return new[] { PSSyntheticTypeName.Create(type, syntheticTypeName.Members) };

}

}

var psTypeName = type != null ? new PSTypeName(type) : new PSTypeName(convertExpressionAst.Type.TypeName.FullName);

return new[] { psTypeName };

}

object ICustomAstVisitor.VisitConstantExpression(ConstantExpressionAst constantExpressionAst)

{

var value = constantExpressionAst.Value;

return value != null ? new[] { new PSTypeName(value.GetType()) } : TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitStringConstantExpression(StringConstantExpressionAst stringConstantExpressionAst)

{

return new[] { StringPSTypeName };

}

object ICustomAstVisitor.VisitSubExpression(SubExpressionAst subExpressionAst)

{

return subExpressionAst.SubExpression.Accept(this);

}

object ICustomAstVisitor.VisitErrorStatement(ErrorStatementAst errorStatementAst)

{

var inferredTypes = new List<PSTypeName>();

if (errorStatementAst.Conditions is not null)

{

foreach (var ast in errorStatementAst.Conditions)

{

inferredTypes.AddRange(InferTypes(ast));

}

}

if (errorStatementAst.Bodies is not null)

{

foreach (var ast in errorStatementAst.Bodies)

{

inferredTypes.AddRange(InferTypes(ast));

}

}

if (errorStatementAst.NestedAst is not null)

{

foreach (var ast in errorStatementAst.NestedAst)

{

inferredTypes.AddRange(InferTypes(ast));

}

}

return inferredTypes;

}

object ICustomAstVisitor.VisitErrorExpression(ErrorExpressionAst errorExpressionAst)

{

var inferredTypes = new List<PSTypeName>();

foreach (var ast in errorExpressionAst.NestedAst)

{

inferredTypes.AddRange(InferTypes(ast));

}

return inferredTypes;

}

object ICustomAstVisitor.VisitScriptBlock(ScriptBlockAst scriptBlockAst)

{

var res = new List<PSTypeName>(10);

var beginBlock = scriptBlockAst.BeginBlock;

var processBlock = scriptBlockAst.ProcessBlock;

var endBlock = scriptBlockAst.EndBlock;

// The following is used when we don't find OutputType, which is checked elsewhere.

if (beginBlock != null)

{

res.AddRange(InferTypes(beginBlock));

}

if (processBlock != null)

{

res.AddRange(InferTypes(processBlock));

}

if (endBlock != null)

{

res.AddRange(InferTypes(endBlock));

}

return res;

}

object ICustomAstVisitor.VisitParamBlock(ParamBlockAst paramBlockAst)

{

return TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitNamedBlock(NamedBlockAst namedBlockAst)

{

var inferredTypes = new List<PSTypeName>();

for (var index = 0; index < namedBlockAst.Statements.Count; index++)

{

var ast = namedBlockAst.Statements[index];

inferredTypes.AddRange(InferTypes(ast));

}

return inferredTypes;

}

object ICustomAstVisitor.VisitTypeConstraint(TypeConstraintAst typeConstraintAst)

{

return TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitAttribute(AttributeAst attributeAst)

{

return TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitNamedAttributeArgument(NamedAttributeArgumentAst namedAttributeArgumentAst)

{

return TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitParameter(ParameterAst parameterAst)

{

var res = new List<PSTypeName>();

var attributes = parameterAst.Attributes;

bool typeConstraintAdded = false;

foreach (var attrib in attributes)

{

switch (attrib)

{

case TypeConstraintAst typeConstraint:

if (!typeConstraintAdded)

{

res.Add(new PSTypeName(typeConstraint.TypeName));

typeConstraintAdded = true;

}

break;

case AttributeAst attributeAst:

PSTypeNameAttribute attribute = null;

try

{

attribute = attributeAst.GetAttribute() as PSTypeNameAttribute;

}

catch (RuntimeException)

{

}

if (attribute != null)

{

res.Add(new PSTypeName(attribute.PSTypeName));

}

break;

}

}

return res;

}

object ICustomAstVisitor.VisitFunctionDefinition(FunctionDefinitionAst functionDefinitionAst)

{

return TypeInferenceContext.EmptyPSTypeNameArray;

}

object ICustomAstVisitor.VisitStatementBlock(StatementBlockAst statementBlockAst)

{

var inferredTypes = new List<PSTypeName>();

foreach (var ast in statementBlockAst.Statements)

{

inferredTypes.AddRange(InferTypes(ast));

}

return inferredTypes;

}

object ICustomAstVisitor.VisitIfStatement(IfStatementAst ifStmtAst)

{

var res = new List<PSTypeName>();

foreach (var clause in ifStmtAst.Clauses)

{

res.AddRange(InferTypes(clause.Item2));

}

var elseClause = ifStmtAst.ElseClause;

if (elseClause != null)

{

res.AddRange(InferTypes(elseClause));

}

return res;

}

object ICustomAstVisitor.VisitTrap(TrapStatementAst trapStatementAst)

{

return trapStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitSwitchStatement(SwitchStatementAst switchStatementAst)

{

var res = new List<PSTypeName>(8);

var clauses = switchStatementAst.Clauses;

var defaultStatement = switchStatementAst.Default;

foreach (var clause in clauses)

{

res.AddRange(InferTypes(clause.Item2));

}

if (defaultStatement != null)

{

res.AddRange(InferTypes(defaultStatement));

}

return res;

}

object ICustomAstVisitor.VisitDataStatement(DataStatementAst dataStatementAst)

{

return dataStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitForEachStatement(ForEachStatementAst forEachStatementAst)

{

return forEachStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitDoWhileStatement(DoWhileStatementAst doWhileStatementAst)

{

return doWhileStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitForStatement(ForStatementAst forStatementAst)

{

return forStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitWhileStatement(WhileStatementAst whileStatementAst)

{

return whileStatementAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitCatchClause(CatchClauseAst catchClauseAst)

{

return catchClauseAst.Body.Accept(this);

}

object ICustomAstVisitor.VisitTryStatement(TryStatementAst tryStatementAst)

{

var res = new List<PSTypeName>(5);

res.AddRange(InferTypes(tryStatementAst.Body));

foreach (var catchClauseAst in tryStatementAst.CatchClauses)

{

res.AddRange(InferTypes(catchClauseAst));

}

if (tryStatementAst.Finally != null)

{

res.AddRange(InferTypes(tryStatementAst.Finally));

}

return res;