Merge pull request #8 from PowerShell/working

Implement checking for correct return types of functions in DSC Class

Author: quoctruong

Engine/Helper.cs

@@ -380,6 +380,23 @@ public bool IsVariableGlobalOrEnvironment(VariableExpressionAst varAst, Ast ast)
             return VariableAnalysisDictionary[ast].IsGlobalOrEnvironment(varAst);
         }
 
+        /// <summary>
+        /// Checks whether all the code path of ast returns.
+        /// Runs InitializeVariableAnalysis before calling this method
+        /// </summary>
+        /// <param name="ast"></param>
+        /// <returns></returns>
+        public bool AllCodePathReturns(Ast ast)
+        {
+            if (!VariableAnalysisDictionary.ContainsKey(ast))
+            {
+                return true;
+            }
+
+            var analysis = VariableAnalysisDictionary[ast];
+            return analysis.Exit._predecessors.All(block => block._returns || block._unreachable || block._throws);
+        }
+
         /// <summary>
         /// Initialize Variable Analysis on Ast ast
         /// </summary>
@@ -400,6 +417,93 @@ public void InitializeVariableAnalysis(Ast ast)
             catch { }
         }
 
+        /// <summary>
+        /// Get the return type of ret, which is used in function funcAst in scriptAst ast
+        /// This function assumes that initialize variable analysis is already run on funcast
+        /// It also assumes that the pipeline of ret is not null
+        /// </summary>
+        /// <param name="funcAst"></param>
+        /// <param name="ret"></param>
+        /// <param name="classes"></param>
+        /// <param name="scriptAst"></param>
+        /// <returns></returns>
+        public string GetTypeFromReturnStatementAst(Ast funcAst, ReturnStatementAst ret, IEnumerable<TypeDefinitionAst> classes, Ast scriptAst)
+        {
+            if (ret == null)
+            {
+                return String.Empty;
+            }
+
+            PipelineAst pipe = ret.Pipeline as PipelineAst;
+
+            // Handle the case with 1 pipeline element first
+            if (pipe != null && pipe.PipelineElements.Count == 1)
+            {
+                CommandExpressionAst cmAst = pipe.PipelineElements[0] as CommandExpressionAst;
+                if (cmAst != null)
+                {
+                    if (cmAst.Expression.StaticType != typeof(object))
+                    {
+                        return cmAst.Expression.StaticType.FullName;
+                    }
+
+                    VariableExpressionAst varAst = cmAst.Expression as VariableExpressionAst;
+
+                    if (varAst != null)
+                    {
+                        return GetVariableTypeFromAnalysis(varAst, funcAst);
+                    }
+
+                    MemberExpressionAst memAst = cmAst.Expression as MemberExpressionAst;
+
+                    if (memAst != null)
+                    {
+                        VariableAnalysisDetails details = null;
+                        TypeDefinitionAst psClass = null;
+
+                        if (memAst.Expression is VariableExpressionAst && VariableAnalysisDictionary.ContainsKey(scriptAst))
+                        {
+                            VariableAnalysis VarTypeAnalysis = VariableAnalysisDictionary[scriptAst];
+                            details = VarTypeAnalysis.GetVariableAnalysis(memAst.Expression as VariableExpressionAst);
+
+                            if (details != null && classes != null)
+                            {
+                                psClass = classes.FirstOrDefault(item => String.Equals(item.Name, details.Type.FullName, StringComparison.OrdinalIgnoreCase));
+                            }
+                        }
+
+                        return GetTypeFromMemberExpressionAst(memAst, psClass, details);
+                    }
+
+                }
+            }
+
+            return String.Empty;
+        }
+
+        /// <summary>
+        /// Retrieves the type from member expression ast
+        /// </summary>
+        /// <param name="memberAst"></param>
+        /// <param name="psClass"></param>
+        /// <param name="analysisDetails"></param>
+        /// <returns></returns>
+        public string GetTypeFromMemberExpressionAst(MemberExpressionAst memberAst, TypeDefinitionAst psClass, VariableAnalysisDetails analysisDetails)
+        {
+            Type result = AssignmentTarget.GetTypeFromMemberExpressionAst(memberAst);
+
+            if (result == null && psClass != null && analysisDetails != null)
+            {
+                result = AssignmentTarget.GetTypeFromMemberExpressionAst(memberAst, analysisDetails, psClass);
+            }
+
+            if (result != null)
+            {
+                return result.FullName;
+            }
+
+            return String.Empty;
+        }
 
         /// <summary>
         /// Get type of variable from the variable analysis
@@ -421,7 +525,8 @@ public string GetVariableTypeFromAnalysis(VariableExpressionAst varAst, Ast ast)
                     return "";
                 }
             }
-            catch {
+            catch
+            {
                 return "";
             }
         }
@@ -440,8 +545,6 @@ public bool HasSpecialVars(string varName)
             return false;
         }
 
-       
-
         #endregion
     }
 

Engine/SpecialVars.cs

@@ -16,6 +16,7 @@ namespace Microsoft.Windows.Powershell.ScriptAnalyzer
 {
     internal class SpecialVars
     {
+        internal static object ThisVariable = new object();
         internal const string @foreach = "foreach";
         internal const string @switch = "switch";
         internal const string Question = "?";
@@ -100,28 +101,28 @@ static SpecialVars()
                                                                     /* ConfirmPreference */ typeof(ConfirmImpact),  
                                                                 };
 
-        internal enum AutomaticVariable  
-        {  
-            Underbar = 0,  
-            Args = 1,  
-            This = 2,  
-            Input = 3,  
-            PSCmdlet = 4,  
-            PSBoundParameters = 5,  
-            MyInvocation = 6,  
-            PSScriptRoot = 7,  
-            PSCommandPath = 8,  
+        internal enum AutomaticVariable
+        {
+            Underbar = 0,
+            Args = 1,
+            This = 2,
+            Input = 3,
+            PSCmdlet = 4,
+            PSBoundParameters = 5,
+            MyInvocation = 6,
+            PSScriptRoot = 7,
+            PSCommandPath = 8,
             NumberOfAutomaticVariables // 1 + the last, used to initialize global scope.
-        }  
-  
-        internal enum PreferenceVariable  
-        {  
-            Debug = 9,  
-            Verbose = 10,  
-            Error = 11,  
-            WhatIf = 12,  
-            Warning = 13,  
-            Confirm = 14,  
+        }
+
+        internal enum PreferenceVariable
+        {
+            Debug = 9,
+            Verbose = 10,
+            Error = 11,
+            WhatIf = 12,
+            Warning = 13,
+            Confirm = 14,
         }
 
         internal const string HistorySize = "MaximumHistoryCount";

Engine/VariableAnalysis.cs

@@ -31,31 +31,6 @@ public VariableAnalysis(IFlowGraph decorated) : base(decorated) { }
         private readonly List<LoopGotoTargets> _loopTargets = new List<LoopGotoTargets>();
         private Dictionary<string, VariableAnalysisDetails> VariablesDictionary;
 
-        /// <summary>
-        /// Used to analyze scriptbloct, functionmemberast or functiondefinitionast
-        /// </summary>
-        /// <param name="ast"></param>
-        /// <returns></returns>
-        public static void Analyze(Ast ast)
-        {
-            if (ast == null) return;
-
-            (new VariableAnalysis(new FlowGraph())).AnalyzeImpl(ast);
-        }
-
-        /// <summary>
-        /// Analyze a member function, marking variable references as "dynamic" (so they can be reported as errors)
-        /// and also analyze the control flow to make sure every block returns (or throws)
-        /// </summary>
-        /// <param name="ast"></param>
-        /// <returns></returns>
-        public static bool AnalyzeMemberFunction(Ast ast)
-        {
-            VariableAnalysis va = (new VariableAnalysis(new FlowGraph()));
-            va.AnalyzeImpl(ast);
-            return va.Exit._predecessors.All(b => b._returns || b._throws || b._unreachable);
-        }
-
         /// <summary>
         /// Return parameters of a functionmemberast or functiondefinitionast
         /// </summary>
@@ -86,10 +61,8 @@ private IEnumerable<ParameterAst> FindParameters(Ast ast, Type type)
             }
         }
 
-        private Dictionary<String, VariableTarget> ProcessParameters(IEnumerable<ParameterAst> parameters)
+        private void ProcessParameters(IEnumerable<ParameterAst> parameters)
         {
-            Dictionary<String, VariableTarget> varTargets = new Dictionary<String, VariableTarget>();
-
             foreach (var parameter in parameters)
             {
                 var variablePath = parameter.Name.VariablePath;
@@ -128,7 +101,7 @@ private Dictionary<String, VariableTarget> ProcessParameters(IEnumerable<Paramet
 
                 var varName = AssignmentTarget.GetUnaliasedVariableName(variablePath);
                 var details = _variables[varName];
-                type = type ?? details.Type ?? typeof(object);
+                details.Type = type ?? details.Type ?? typeof(object);
 
                 if (parameter.DefaultValue != null)
                 {
@@ -147,24 +120,13 @@ private Dictionary<String, VariableTarget> ProcessParameters(IEnumerable<Paramet
                     // Consider switch or mandatory parameter as already initialized
                     Entry.AddAst(new AssignmentTarget(varName, type));
                 }
-                else if (type != typeof(object))
+                else
                 {
                     VariableTarget varTarget = new VariableTarget(parameter.Name);
-                    varTarget.Type = type;
-                    if (!varTargets.ContainsKey(varTarget.Name))
-                    {
-                        varTargets.Add(varTarget.Name, varTarget);
-                    }
-
+                    varTarget.Type = details.Type;
                     Entry.AddAst(varTarget);
                 }
-                else
-                {
-                    Entry.AddAst(new VariableTarget(parameter.Name));
-                }
             }
-
-            return varTargets;
         }
 
         /// <summary>
@@ -181,24 +143,22 @@ public void AnalyzeImpl(Ast ast)
 
             _variables = FindAllVariablesVisitor.Visit(ast);
 
-            Dictionary<String, VariableTarget> varTargets = null;
-
             Init();
 
             if (ast is FunctionMemberAst || ast is FunctionDefinitionAst)
             {
                 IEnumerable<ParameterAst> parameters = FindParameters(ast, ast.GetType());
                 if (parameters != null)
                 {
-                    varTargets = ProcessParameters(parameters);
+                    ProcessParameters(parameters);
                 }
             }
             else
             {
                 ScriptBlockAst sbAst = ast as ScriptBlockAst;
                 if (sbAst != null && sbAst.ParamBlock != null && sbAst.ParamBlock.Parameters != null)
                 {
-                    varTargets = ProcessParameters(sbAst.ParamBlock.Parameters);
+                    ProcessParameters(sbAst.ParamBlock.Parameters);
                 }
             }
 
@@ -215,29 +175,18 @@ public void AnalyzeImpl(Ast ast)
                 ast.Visit(this.Decorator);
             }
 
-            VariablesDictionary = Block.SparseSimpleConstants(_variables, Entry);
+            Ast parent = ast;
 
-            // Update the type of variables in VariablesDictionary based on the param block
-            foreach (var entry in VariablesDictionary)
+            while (parent.Parent != null)
             {
-                var analysisDetails = entry.Value;
-                if (analysisDetails.Type != typeof(Unreached))
-                {
-                    continue;
-                }
-
-                // This regex is used to extracts the variable name from entry.Key. The key is of the form [varname]s[so]e[eo]
-                // where [varname] is name of variable [so] is the start offset number and [eo] is the end offset number
-                var result = Regex.Match(entry.Key, "^(.+)s[0-9]+e[0-9]+$");
-                if (result.Success && result.Groups.Count == 2)
-                {
-                    string varName = result.Groups[1].Value;
-                    if (varTargets.ContainsKey(varName))
-                    {
-                        analysisDetails.Type = varTargets[varName].Type;
-                    }
-                }
+                parent = parent.Parent;
             }
+
+            List<TypeDefinitionAst> classes = parent.FindAll(item =>
+                item is TypeDefinitionAst && (item as TypeDefinitionAst).IsClass, true)
+                .Cast<TypeDefinitionAst>().ToList();
+
+            VariablesDictionary = Block.SparseSimpleConstants(_variables, Entry, classes);
         }
 
         /// <summary>
@@ -292,7 +241,7 @@ public bool IsUninitialized(VariableExpressionAst varTarget)
             }
 
             var analysis = GetVariableAnalysis(varTarget);
-            
+
             if (analysis == null)
             {
                 return false;
@@ -315,9 +264,9 @@ public bool IsGlobalOrEnvironment(VariableExpressionAst varTarget)
                 return (varTarget.VariablePath.IsGlobal
                         || String.Equals(varTarget.VariablePath.DriveName, "env", StringComparison.OrdinalIgnoreCase));
             }
-           
+
             return false;
-            
+
         }
 
         /// <summary>
@@ -391,7 +340,7 @@ public override object VisitAssignmentStatement(AssignmentStatementAst assignmen
                     // We skip things like $a.test = 3. In this case we will just test
                     // for variable $a
                     assignTarget.Visit(this.Decorator);
-                }                
+                }
             }
 
             return null;