Allow TypeNotFound parser errors

Engine/ScriptAnalyzer.cs

@@ -1522,16 +1522,18 @@ public IEnumerable<DiagnosticRecord> AnalyzeScriptDefinition(string scriptDefini
                 return null;
             }
 
-            if (errors != null && errors.Length > 0)
+            var relevantParseErrors = RemoveTypeNotFoundParseErrors(errors);
+
+            if (relevantParseErrors != null && relevantParseErrors.Count > 0)
             {
-                foreach (ParseError error in errors)
+                foreach (ParseError error in relevantParseErrors)
                 {
                     string parseErrorMessage = String.Format(CultureInfo.CurrentCulture, Strings.ParseErrorFormatForScriptDefinition, error.Message.TrimEnd('.'), error.Extent.StartLineNumber, error.Extent.StartColumnNumber);
                     this.outputWriter.WriteError(new ErrorRecord(new ParseException(parseErrorMessage), parseErrorMessage, ErrorCategory.ParserError, error.ErrorId));
                 }
             }
 
-            if (errors != null && errors.Length > 10)
+            if (relevantParseErrors != null && relevantParseErrors.Count > 10)
             {
                 string manyParseErrorMessage = String.Format(CultureInfo.CurrentCulture, Strings.ParserErrorMessageForScriptDefinition);
                 this.outputWriter.WriteError(new ErrorRecord(new ParseException(manyParseErrorMessage), manyParseErrorMessage, ErrorCategory.ParserError, scriptDefinition));
@@ -1644,6 +1646,31 @@ private static Encoding GetFileEncoding(string path)
             }
         }
 
+        /// <summary>
+        /// Inspects Parse errors and removes TypeNotFound errors that can be ignored that can be due to types that are not known yet (e.g. due to 'using' statements)
+        /// </summary>
+        /// <param name="parseErrors"></param>
+        /// <returns>List of relevant parse errors.</returns>
+        private List<ParseError> RemoveTypeNotFoundParseErrors(ParseError[] parseErrors)
+        {
+            var relevantParseErrors = new List<ParseError>();
+            foreach(var parseError in parseErrors)
+            {
+                // If types are not known due them not being imported yet, the parser throws an error that can be ignored
+                if (parseError.ErrorId != "TypeNotFound")
+                {
+                    relevantParseErrors.Add(parseError);
+                }
+                else
+                {
+                    this.outputWriter.WriteVerbose(
+                        $"Ignoring 'TypeNotFound' parse error on type {parseError.Extent}, which is likely due to the type not being knowm due to e.g. 'using' statements. Parse error message was '{parseError.Message}'.");
+                }
+            }
+
+            return relevantParseErrors;
+        }
+
         private static Range SnapToEdges(EditableText text, Range range)
         {
             // todo add TextLines.Validate(range) and TextLines.Validate(position)
@@ -1829,17 +1856,19 @@ private IEnumerable<DiagnosticRecord> AnalyzeFile(string filePath)
                         scriptAst = Parser.ParseFile(filePath, out scriptTokens, out errors);
                     }
 #endif //!PSV3
+                    var relevantParseErrors = RemoveTypeNotFoundParseErrors(errors);
+
                     //Runspace.DefaultRunspace = oldDefault;
-                    if (errors != null && errors.Length > 0)
+                    if (relevantParseErrors != null && relevantParseErrors.Count > 0)
                     {
-                        foreach (ParseError error in errors)
+                        foreach (ParseError error in relevantParseErrors)
                         {
                             string parseErrorMessage = String.Format(CultureInfo.CurrentCulture, Strings.ParserErrorFormat, error.Extent.File, error.Message.TrimEnd('.'), error.Extent.StartLineNumber, error.Extent.StartColumnNumber);
                             this.outputWriter.WriteError(new ErrorRecord(new ParseException(parseErrorMessage), parseErrorMessage, ErrorCategory.ParserError, error.ErrorId));
                         }
                     }
 
-                    if (errors != null && errors.Length > 10)
+                    if (relevantParseErrors != null && relevantParseErrors.Count > 10)
                     {
                         string manyParseErrorMessage = String.Format(CultureInfo.CurrentCulture, Strings.ParserErrorMessage, System.IO.Path.GetFileName(filePath));
                         this.outputWriter.WriteError(new ErrorRecord(new ParseException(manyParseErrorMessage), manyParseErrorMessage, ErrorCategory.ParserError, filePath));

Tests/Engine/InvokeScriptAnalyzer.tests.ps1

@@ -562,4 +562,27 @@ Describe "Test -EnableExit Switch" {
             "$result" | Should -Not -BeLike $reportSummaryFor1Warning 
         }
     }
+
+    if (!$testingLibraryUsage) {
+        Describe "Handles parse errors due to unknown types" {
+            $script = @'
+                using namespace Microsoft.Azure.Commands.ResourceManager.Cmdlets.SdkModels
+                using namespace Microsoft.Azure.Commands.Common.Authentication.Abstractions
+                Import-Module "AzureRm"
+                class MyClass { [IStorageContext]$StorageContext } # This will result in a parser error due to [IStorageContext] type that comes from the using stetement but is not known at parse time
+                gci # Produce AvoidAlias rule
+'@
+            It "does not throw and detect one expected warning after the parse error has occured when using -ScriptDefintion parameter set" {
+                $warnings = Invoke-ScriptAnalyzer -ScriptDefinition $script
+                $warnings.Count | Should -Be 1 -Because 'PSSA should analyze the whole script after the parse error on [IStorageContext] and find the AvoidAlias warning due to gci'
+            }
+
+            $testFilePath = "TestDrive:\testfile.ps1"
+            Set-Content $testFilePath -value $script
+            It "does not throw and detect one expected warning after the parse error has occured when using -Path parameter set" {
+                $warnings = Invoke-ScriptAnalyzer -Path $testFilePath
+                $warnings.Count | Should -Be 1 -Because 'PSSA should analyze the whole script after the parse error on [IStorageContext] and find the AvoidAlias warning due to gci'
+            }
+        }
+    }
 }