First commit for PSv3 Support

Author: raghushantha

Engine/Commands/InvokeScriptAnalyzerCommand.cs

@@ -43,7 +43,9 @@ public class InvokeScriptAnalyzerCommand : PSCmdlet, IOutputWriter
         /// </summary>
         [Parameter(Position = 0,
             ParameterSetName = "File",
-            Mandatory = true)]
+            Mandatory = true,
+            ValueFromPipeline = true, 
+            ValueFromPipelineByPropertyName = true)]
         [ValidateNotNull]
         [Alias("PSPath")]
         public string Path
@@ -58,7 +60,9 @@ public string Path
         /// </summary>
         [Parameter(Position = 0,
             ParameterSetName = "ScriptDefinition",
-            Mandatory = true)]
+            Mandatory = true,
+            ValueFromPipeline = true,
+            ValueFromPipelineByPropertyName = true)]
         [ValidateNotNull]
         public string ScriptDefinition
         {

Engine/Generic/IDSCResourceRule.cs

@@ -28,13 +28,17 @@ public interface IDSCResourceRule : IRule
         /// <returns>The results of the analysis</returns>
         IEnumerable<DiagnosticRecord> AnalyzeDSCResource(Ast ast, string fileName);
 
+        #if !PSV3
+
         /// <summary>
         /// Analyze dsc classes (if any) in the file
         /// </summary>
         /// <param name="ast"></param>
         /// <param name="fileName"></param>
         /// <returns></returns>
         IEnumerable<DiagnosticRecord> AnalyzeDSCClass(Ast ast, string fileName);
- 
+
+        #endif
+
     }
 }

Engine/Generic/RuleSuppression.cs

@@ -367,10 +367,14 @@ public static List<RuleSuppression> GetSuppressions(IEnumerable<AttributeAst> at
                             targetAsts = scopeAst.FindAll(item => item is FunctionDefinitionAst && reg.IsMatch((item as FunctionDefinitionAst).Name), true);
                             goto default;
 
+                        #if !PSV3
+
                         case "class":
                             targetAsts = scopeAst.FindAll(item => item is TypeDefinitionAst && reg.IsMatch((item as TypeDefinitionAst).Name), true);
                             goto default;
 
+                        #endif
+
                         default:
                             break;
                     }

Engine/Helper.cs

@@ -619,7 +619,16 @@ internal VariableAnalysis InitializeVariableAnalysisHelper(Ast ast, VariableAnal
         /// <param name="classes"></param>
         /// <param name="scriptAst"></param>
         /// <returns></returns>
+        
+        #if PSV3
+
+        public string GetTypeFromReturnStatementAst(Ast funcAst, ReturnStatementAst ret)
+
+        #else
+
         public string GetTypeFromReturnStatementAst(Ast funcAst, ReturnStatementAst ret, IEnumerable<TypeDefinitionAst> classes)
+
+        #endif
         {
             if (ret == null || funcAst == null)
             {
@@ -650,7 +659,15 @@ public string GetTypeFromReturnStatementAst(Ast funcAst, ReturnStatementAst ret,
                         }
                         else if (cmAst.Expression is MemberExpressionAst)
                         {
+                            #if PSV3
+
+                            result = GetTypeFromMemberExpressionAst(cmAst.Expression as MemberExpressionAst, funcAst);
+
+                            #else
+
                             result = GetTypeFromMemberExpressionAst(cmAst.Expression as MemberExpressionAst, funcAst, classes);
+
+                            #endif
                         }
                     }
                 }
@@ -673,30 +690,56 @@ public string GetTypeFromReturnStatementAst(Ast funcAst, ReturnStatementAst ret,
         /// <param name="scopeAst"></param>
         /// <param name="classes"></param>
         /// <returns></returns>
+        
+        #if PSV3
+
+        public string GetTypeFromMemberExpressionAst(MemberExpressionAst memberAst, Ast scopeAst)
+
+        #else
+
         public string GetTypeFromMemberExpressionAst(MemberExpressionAst memberAst, Ast scopeAst, IEnumerable<TypeDefinitionAst> classes)
+
+        #endif        
         {
             if (memberAst == null)
             {
                 return String.Empty;
             }
 
             VariableAnalysisDetails details = null;
+
+            #if !PSV3
+
             TypeDefinitionAst psClass = null;
 
+            #endif
+
             if (memberAst.Expression is VariableExpressionAst && VariableAnalysisDictionary.ContainsKey(scopeAst))
             {
                 VariableAnalysis VarTypeAnalysis = VariableAnalysisDictionary[scopeAst];
                 // Get the analysis detail for the variable
                 details = VarTypeAnalysis.GetVariableAnalysis(memberAst.Expression as VariableExpressionAst);
 
+                #if !PSV3
+
                 if (details != null && classes != null)
                 {
                     // Get the class that corresponds to the name of the type (if possible)
                     psClass = classes.FirstOrDefault(item => String.Equals(item.Name, details.Type.FullName, StringComparison.OrdinalIgnoreCase));
                 }
+
+                #endif
             }
 
-            return GetTypeFromMemberExpressionAstHelper(memberAst, psClass, details);
+            #if PSV3
+
+                return GetTypeFromMemberExpressionAstHelper(memberAst, details);
+
+            #else
+
+                return GetTypeFromMemberExpressionAstHelper(memberAst, psClass, details);
+
+            #endif         
         }
 
         /// <summary>
@@ -707,17 +750,30 @@ public string GetTypeFromMemberExpressionAst(MemberExpressionAst memberAst, Ast
         /// <param name="psClass"></param>
         /// <param name="analysisDetails"></param>
         /// <returns></returns>
+        
+        #if PSV3
+        
+        internal string GetTypeFromMemberExpressionAstHelper(MemberExpressionAst memberAst, VariableAnalysisDetails analysisDetails)
+
+        #else
+
         internal string GetTypeFromMemberExpressionAstHelper(MemberExpressionAst memberAst, TypeDefinitionAst psClass, VariableAnalysisDetails analysisDetails)
+
+        #endif
         {
             //Try to get the type without using psClass first
             Type result = AssignmentTarget.GetTypeFromMemberExpressionAst(memberAst);
 
+            #if !PSV3
+
             //If we can't get the type, then it may be that the type of the object being invoked on is a powershell class
             if (result == null && psClass != null && analysisDetails != null)
             {
                 result = AssignmentTarget.GetTypeFromMemberExpressionAst(memberAst, analysisDetails, psClass);
             }
 
+            #endif
+
             if (result != null)
             {
                 return result.FullName;
@@ -816,6 +872,8 @@ public Dictionary<string, List<RuleSuppression>> GetRuleSuppression(Ast ast)
                 ruleSuppressionList.AddRange(GetSuppressionsFunction(funcAst));
             }
 
+            #if !PSV3
+
             // Get rule suppression from classes
             IEnumerable<TypeDefinitionAst> typeAsts = ast.FindAll(item => item is TypeDefinitionAst, true).Cast<TypeDefinitionAst>();
 
@@ -824,6 +882,8 @@ public Dictionary<string, List<RuleSuppression>> GetRuleSuppression(Ast ast)
                 ruleSuppressionList.AddRange(GetSuppressionsClass(typeAst));
             }
 
+            #endif
+
             ruleSuppressionList.Sort((item, item2) => item.StartOffset.CompareTo(item2.StartOffset));
 
             foreach (RuleSuppression ruleSuppression in ruleSuppressionList)
@@ -1089,7 +1149,15 @@ public object VisitScriptBlock(ScriptBlockAst scriptBlockAst)
 
             // We already run variable analysis if the parent is a function so skip these.
             // Otherwise, we have to do variable analysis using the outer scope variables.
+            #if PSV3
+
+                if (!(scriptBlockAst.Parent is FunctionDefinitionAst))
+
+            #else
+
             if (!(scriptBlockAst.Parent is FunctionDefinitionAst) && !(scriptBlockAst.Parent is FunctionMemberAst))
+
+            #endif
             {
                 OuterAnalysis = Helper.Instance.InitializeVariableAnalysisHelper(scriptBlockAst, OuterAnalysis);
             }
@@ -1117,7 +1185,15 @@ public object VisitScriptBlock(ScriptBlockAst scriptBlockAst)
             VariableAnalysis innerAnalysis = OuterAnalysis;
             OuterAnalysis = previousOuter;
 
+            #if PSV3
+
+            if (!(scriptBlockAst.Parent is FunctionDefinitionAst))
+
+            #else
+
             if (!(scriptBlockAst.Parent is FunctionDefinitionAst) && !(scriptBlockAst.Parent is FunctionMemberAst))
+
+            #endif
             {
                 // Update the variable analysis of the outer script block
                 VariableAnalysis.UpdateOuterAnalysis(OuterAnalysis, innerAnalysis);
@@ -1138,6 +1214,12 @@ private object VisitStatementHelper(StatementAst statementAst)
                 return null;
             }
 
+            #if PSV3
+
+            statementAst.Visit(this);
+            
+            #else
+
             TypeDefinitionAst typeAst = statementAst as TypeDefinitionAst;
 
             if (typeAst == null)
@@ -1164,9 +1246,13 @@ private object VisitStatementHelper(StatementAst statementAst)
                 }
             }
 
+            #endif
+
             return null;
         }
 
+        #if !PSV3
+
         /// <summary>
         /// Do nothing
         /// </summary>
@@ -1177,6 +1263,8 @@ public object VisitUsingStatement(UsingStatementAst usingStatement)
             return null;
         }
 
+        #endif
+
         /// <summary>
         /// Do nothing
         /// </summary>
@@ -1842,8 +1930,12 @@ public class FindPipelineOutput : ICustomAstVisitor
     {
         List<Tuple<string, StatementAst>> outputTypes;
 
+        #if !PSV3
+
         IEnumerable<TypeDefinitionAst> classes;
 
+        #endif
+
         FunctionDefinitionAst myFunction;
         /// <summary>
         /// These binary operators will always return boolean value
@@ -1879,10 +1971,25 @@ static FindPipelineOutput()
         /// Find the pipeline output
         /// </summary>
         /// <param name="ast"></param>
+        
+        #if PSV3
+
+        public FindPipelineOutput(FunctionDefinitionAst ast)
+
+        #else
+
         public FindPipelineOutput(FunctionDefinitionAst ast, IEnumerable<TypeDefinitionAst> classes)
+
+        #endif
         {
             outputTypes = new List<Tuple<string, StatementAst>>();
+
+            #if !PSV3
+
             this.classes = classes;
+
+            #endif
+
             myFunction = ast;
 
             if (myFunction != null)
@@ -1895,11 +2002,22 @@ public FindPipelineOutput(FunctionDefinitionAst ast, IEnumerable<TypeDefinitionA
         /// Get list of outputTypes from functiondefinitionast funcast
         /// </summary>
         /// <returns></returns>
+        
+        #if PSV3
+
+        public static List<Tuple<string, StatementAst>> OutputTypes(FunctionDefinitionAst funcAst)
+        {
+            return (new FindPipelineOutput(funcAst)).outputTypes;
+        }
+
+        #else
         public static List<Tuple<string, StatementAst>> OutputTypes(FunctionDefinitionAst funcAst, IEnumerable<TypeDefinitionAst> classes)
         {
             return (new FindPipelineOutput(funcAst, classes)).outputTypes;
         }
 
+        #endif
+
         /// <summary>
         /// Ignore assignment statement
         /// </summary>
@@ -2351,7 +2469,15 @@ public object VisitCommandExpression(CommandExpressionAst commandAst)
         /// <returns></returns>
         public object VisitReturnStatement(ReturnStatementAst returnStatementAst)
         {
+            #if PSV3
+
+            return Helper.Instance.GetTypeFromReturnStatementAst(myFunction, returnStatementAst);
+
+            #else
+
             return Helper.Instance.GetTypeFromReturnStatementAst(myFunction, returnStatementAst, classes);
+
+            #endif            
         }
 
         /// <summary>
@@ -2361,7 +2487,15 @@ public object VisitReturnStatement(ReturnStatementAst returnStatementAst)
         /// <returns></returns>
         public object VisitMemberExpression(MemberExpressionAst memAst)
         {
+            #if PSV3
+
+            return Helper.Instance.GetTypeFromMemberExpressionAst(memAst, myFunction);
+
+            #else
+
             return Helper.Instance.GetTypeFromMemberExpressionAst(memAst, myFunction, classes);
+
+            #endif
         }
 
         /// <summary>
@@ -2371,7 +2505,15 @@ public object VisitMemberExpression(MemberExpressionAst memAst)
         /// <returns></returns>
         public object VisitInvokeMemberExpression(InvokeMemberExpressionAst invokeAst)
         {
+            #if PSV3
+
+            return Helper.Instance.GetTypeFromMemberExpressionAst(invokeAst, myFunction);
+
+            #else
+
             return Helper.Instance.GetTypeFromMemberExpressionAst(invokeAst, myFunction, classes);
+
+            #endif
         }
 
         /// <summary>