COM return types resolved; added global "Err As ErrObject" variable in VBA scope; added "Debug As DebugClass" variable in VBA scope, but it doesn't seem to resolve. Parse timing issue still unresolved.

retailcoder · retailcoder · commit f64ba33d0b78 · 2016-04-25T01:54:13.000-04:00
diff --git a/Rubberduck.Parsing/Symbols/DeclarationFinder.cs b/Rubberduck.Parsing/Symbols/DeclarationFinder.cs
@@ -92,10 +92,11 @@ public IEnumerable<Declaration> MatchName(string name)
             {
                 return result;
             }
+
             return new List<Declaration>();
         }
 
-        public Declaration FindProject(Declaration currentScope, string name)
+        public Declaration FindProject(string name, Declaration currentScope = null)
         {
             Declaration result = null;
             try
diff --git a/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs b/Rubberduck.Parsing/Symbols/IdentifierReferenceResolver.cs
@@ -204,7 +204,7 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)
         private Declaration ResolveType(IList<VBAParser.AmbiguousIdentifierContext> identifiers)
         {
             var first = identifiers[0].GetText();
-            var projectMatch = _declarationFinder.FindProject(_currentScope, first);
+            var projectMatch = _declarationFinder.FindProject(first, _currentScope);
 
             if (projectMatch != null)
             {
@@ -1109,7 +1109,7 @@ private Declaration FindModuleScopeDeclaration(string identifierName, Declaratio
                 .ToList();
             }
 
-            return result.Count == 1 ? result.SingleOrDefault() : null;
+            return result.Count == 1 ? result.SingleOrDefault() : null; // return null for multiple matches
         }
 
         private bool IsLocalEvent(Declaration item, Declaration localScope)
diff --git a/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs b/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.Eventing.Reader;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
 using Microsoft.Vbe.Interop;
@@ -75,6 +76,39 @@ private enum REGKIND
             {VarEnum.VT_R8, "Double"},
         };
 
+        private string GetTypeName(TYPEDESC desc, ITypeInfo info)
+        {
+            var vt = (VarEnum)desc.vt;
+            TYPEDESC tdesc;
+
+            switch (vt)
+            {
+                case VarEnum.VT_PTR:
+                    tdesc = (TYPEDESC) Marshal.PtrToStructure(desc.lpValue, typeof (TYPEDESC));
+                    return GetTypeName(tdesc, info);
+                case VarEnum.VT_USERDEFINED:
+                    unchecked
+                    {
+                        var href = desc.lpValue.ToInt32();
+                        ITypeInfo refTypeInfo;
+                        info.GetRefTypeInfo(href, out refTypeInfo);
+                        return GetTypeName(refTypeInfo);
+                    }
+                case VarEnum.VT_CARRAY:
+                    tdesc = (TYPEDESC) Marshal.PtrToStructure(desc.lpValue, typeof (TYPEDESC));
+                    return GetTypeName(tdesc, info) + "()";
+                default:
+                    string result;
+                    if (TypeNames.TryGetValue(vt, out result))
+                    {
+                        return result;
+                    }
+                    break;
+            }
+
+            return "UNKNOWN";
+        }
+
         private string GetTypeName(ITypeInfo info)
         {
             string typeName;
@@ -203,7 +237,22 @@ private Declaration CreateMemberDeclaration(out FUNCDESC memberDescriptor, TYPEK
             var asTypeName = string.Empty;
             if (memberDeclarationType != DeclarationType.Procedure && !TypeNames.TryGetValue(funcValueType, out asTypeName))
             {
-                asTypeName = funcValueType.ToString(); //TypeNames[VarEnum.VT_VARIANT];
+                if (funcValueType == VarEnum.VT_PTR)
+                {
+                    try
+                    {
+                        var asTypeDesc = (TYPEDESC) Marshal.PtrToStructure(memberDescriptor.elemdescFunc.tdesc.lpValue, typeof (TYPEDESC));
+                        asTypeName = GetTypeName(asTypeDesc, info);
+                    }
+                    catch
+                    {
+                        asTypeName = funcValueType.ToString(); //TypeNames[VarEnum.VT_VARIANT];
+                    }
+                }
+                else
+                {
+                    asTypeName = funcValueType.ToString(); //TypeNames[VarEnum.VT_VARIANT];
+                }
             }
 
             var attributes = new Attributes();
@@ -214,7 +263,7 @@ private Declaration CreateMemberDeclaration(out FUNCDESC memberDescriptor, TYPEK
             else if (memberDescriptor.memid == 0)
             {
                 attributes.AddDefaultMemberAttribute(memberName);
-                Debug.WriteLine("Default member found: {0}.{1} ({2} / {3})", moduleDeclaration.IdentifierName, memberName, memberDeclarationType, (VarEnum)memberDescriptor.elemdescFunc.tdesc.vt);
+                //Debug.WriteLine("Default member found: {0}.{1} ({2} / {3})", moduleDeclaration.IdentifierName, memberName, memberDeclarationType, (VarEnum)memberDescriptor.elemdescFunc.tdesc.vt);
             }
             else if (((FUNCFLAGS)memberDescriptor.wFuncFlags).HasFlag(FUNCFLAGS.FUNCFLAG_FHIDDEN))
             {
diff --git a/Rubberduck.Parsing/Symbols/SyntaxErrorException.cs b/Rubberduck.Parsing/Symbols/SyntaxErrorException.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using Antlr4.Runtime;
 
 namespace Rubberduck.Parsing.Symbols
@@ -16,6 +17,8 @@ public SyntaxErrorException(string message, RecognitionException innerException,
             _token = offendingSymbol;
             _line = line;
             _position = position;
+            Debug.WriteLine(innerException.ToString());
+            Debug.WriteLine("Token: {0} (L{1}C{2})", offendingSymbol.Text, line, position);
         }
 
         private readonly IToken _token;
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -12,6 +12,7 @@
 using System.Globalization;
 using Rubberduck.Parsing.Preprocessing;
 using System.Diagnostics;
+using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Nodes;
 using Rubberduck.VBEditor.Extensions;
@@ -33,10 +34,6 @@ public RubberduckParserState State
         private readonly ConcurrentDictionary<VBComponent, Tuple<Task, CancellationTokenSource>> _currentTasks = 
             new ConcurrentDictionary<VBComponent, Tuple<Task, CancellationTokenSource>>();
 
-        private readonly Dictionary<VBComponent, IParseTree> _parseTrees = new Dictionary<VBComponent, IParseTree>();
-        private readonly Dictionary<QualifiedModuleName, Dictionary<Declaration, byte>> _declarations = new Dictionary<QualifiedModuleName, Dictionary<Declaration, byte>>();
-        private readonly Dictionary<VBComponent, ITokenStream> _tokenStreams = new Dictionary<VBComponent, ITokenStream>();
-        private readonly Dictionary<VBComponent, IList<CommentNode>> _comments = new Dictionary<VBComponent, IList<CommentNode>>();
         private readonly IDictionary<VBComponent, IDictionary<Tuple<string, DeclarationType>, Attributes>> _componentAttributes
             = new Dictionary<VBComponent, IDictionary<Tuple<string, DeclarationType>, Attributes>>();
 
@@ -134,25 +131,26 @@ private void ParseAll()
             }
 
             var projects = _state.Projects.ToList();
-
             var components = projects.SelectMany(p => p.VBComponents.Cast<VBComponent>()).ToList();
-            var modified = components.Where(c => _state.IsNewOrModified(c)).ToList();
+
+            var toParse = components.Where(c => _state.IsNewOrModified(c)).ToList();
             var unchanged = components.Where(c => !_state.IsNewOrModified(c)).ToList();
 
-            SyncComReferences(projects);
+            AddBuiltInDeclarations(projects);
 
-            if (!modified.Any())
+            if (!toParse.Any())
             {
                 return;
             }
 
-            foreach (var component in modified)
+            foreach (var component in toParse)
             {
                 _state.SetModuleState(component, ParserState.Pending);
             }
             foreach (var component in unchanged)
             {
-                _state.SetModuleState(component, ParserState.Parsed);
+                // note: seting to 'Parsed' would include them in the resolver walk. 'Ready' excludes them.
+                _state.SetModuleState(component, ParserState.Ready); 
             }
 
             // invalidation cleanup should go into ParseAsync?
@@ -161,19 +159,55 @@ private void ParseAll()
                 _componentAttributes.Remove(invalidated);
             }
 
-            foreach (var vbComponent in modified)
+            foreach (var vbComponent in toParse)
             {
                 ParseAsync(vbComponent, CancellationToken.None);
             }
         }
 
+        private void AddBuiltInDeclarations(IReadOnlyList<VBProject> projects)
+        {
+            SyncComReferences(projects);
+
+            var finder = new DeclarationFinder(_state.AllDeclarations, new CommentNode[]{}, new IAnnotation[]{});
+            if (finder.MatchName(Tokens.Err).Any(item => item.IsBuiltIn 
+                && item.DeclarationType == DeclarationType.Variable 
+                && item.Accessibility == Accessibility.Global))
+            {
+                return;
+            }
+            
+            var vba = finder.FindProject("VBA");
+            Debug.Assert(vba != null);
+            
+            var errObject = finder.FindClass(vba, "ErrObject", true);
+            Debug.Assert(errObject != null);
+
+            var qualifiedName = new QualifiedModuleName(vba.IdentifierName, vba.IdentifierName, errObject.IdentifierName);
+            var err = new Declaration(new QualifiedMemberName(qualifiedName, Tokens.Err), vba, "Global", errObject.IdentifierName, true, false, Accessibility.Global, DeclarationType.Variable);
+            _state.AddDeclaration(err);
+
+            var debugClassName = new QualifiedModuleName(vba.IdentifierName, vba.IdentifierName, "DebugClass");
+            var debugClass = new Declaration(new QualifiedMemberName(debugClassName, "DebugClass"), vba, "Global", "DebugClass", false, false, Accessibility.Global, DeclarationType.Class);
+            var debugObject = new Declaration(new QualifiedMemberName(debugClassName, "Debug"), vba, "Global", "DebugClass", true, false, Accessibility.Global, DeclarationType.Variable);
+            var debugAssert = new Declaration(new QualifiedMemberName(debugClassName, "Assert"), debugObject, debugObject.Scope, null, false, false, Accessibility.Global, DeclarationType.Procedure);
+            var debugPrint = new Declaration(new QualifiedMemberName(debugClassName, "Print"), debugObject, debugObject.Scope, null, false, false, Accessibility.Global, DeclarationType.Procedure);
+
+            _state.AddDeclaration(debugClass);
+            _state.AddDeclaration(debugObject);
+            _state.AddDeclaration(debugAssert);
+            _state.AddDeclaration(debugPrint);
+        }
+
         private readonly HashSet<ReferencePriorityMap> _references = new HashSet<ReferencePriorityMap>();
 
         private void SyncComReferences(IReadOnlyList<VBProject> projects)
         {
             foreach (var vbProject in projects)
             {
                 var projectId = QualifiedModuleName.GetProjectId(vbProject);
+                // use a 'for' loop to store the order of references as a 'priority'.
+                // reference resolver needs this to know which declaration to prioritize when a global identifier exists in multiple libraries.
                 for (var priority = 1; priority <= vbProject.References.Count; priority++)
                 {
                     var reference = vbProject.References.Item(priority);
@@ -368,7 +402,7 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)
                     emptyStringLiteralListener,
                     argListWithOneByRefParamListener,
                 }), tree);
-                // TODO: these are actually (almost) isnpection results.. we should handle them as such
+                // TODO: these are actually (almost) inspection results.. we should handle them as such
                 _state.ArgListsWithOneByRefParam = argListWithOneByRefParamListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
                 _state.EmptyStringLiterals = emptyStringLiteralListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
                 _state.ObsoleteLetContexts = obsoleteLetStatementListener.Contexts.Select(context => new QualifiedContext(qualifiedModuleName, context));
@@ -382,10 +416,13 @@ private void ResolveDeclarations(VBComponent component, IParseTree tree)
                 declarationsListener.NewDeclaration += (sender, e) => _state.AddDeclaration(e.Declaration);
                 declarationsListener.CreateModuleDeclarations();
                 // rewalk parse tree for second declaration level
+                
+                Debug.WriteLine("Walking parse tree for '{0}'... (acquiring declarations)", qualifiedModuleName.Name);
                 ParseTreeWalker.Default.Walk(declarationsListener, tree);
+
             } catch (Exception exception)
             {
-                Debug.Print("Exception thrown resolving '{0}' (thread {2}): {1}", component.Name, exception, Thread.CurrentThread.ManagedThreadId);
+                Debug.Print("Exception thrown acquiring declarations for '{0}' (thread {2}): {1}", component.Name, exception, Thread.CurrentThread.ManagedThreadId);
                 _state.SetModuleState(component, ParserState.ResolverError);
             }
 
@@ -399,8 +436,8 @@ private void ResolveReferences(DeclarationFinder finder, VBComponent component,
                 return;
             }
 
-            Debug.WriteLine("Resolving '{0}'... (thread {1})", component.Name, Thread.CurrentThread.ManagedThreadId);            
             var qualifiedName = new QualifiedModuleName(component);
+            Debug.WriteLine("Resolving identifier references in '{0}'... (thread {1})", qualifiedName.Name, Thread.CurrentThread.ManagedThreadId);
             var resolver = new IdentifierReferenceResolver(qualifiedName, finder);
             var listener = new IdentifierReferenceListener(resolver);
             if (!string.IsNullOrWhiteSpace(tree.GetText().Trim()))
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -235,8 +235,7 @@ private ParserState EvaluateParserState()
             if (moduleStates.Any(module => module != ParserState.Ready))
             {
                 // now any module not ready means at least one of them has work in progress;
-                // report the least advanced of them, except if that's 'Pending':
-                return moduleStates.Except(new[]{ParserState.Pending}).Min();
+                return moduleStates.Min();
             }
 
             return default(ParserState); // default value is 'Pending'.
@@ -560,7 +559,7 @@ public bool IsNewOrModified(QualifiedModuleName key)
         private QualifiedSelection _lastSelection;
         private Declaration _selectedDeclaration;
 
-        public Declaration FindSelectedDeclaration(CodePane activeCodePane)
+        public Declaration FindSelectedDeclaration(CodePane activeCodePane, bool procedureLevelOnly = false)
         {
             var selection = activeCodePane.GetSelection();
             if (selection.Equals(_lastSelection))
@@ -588,10 +587,17 @@ public Declaration FindSelectedDeclaration(CodePane activeCodePane)
                     }
                     else
                     {
+                        Declaration match = null;
+                        if (procedureLevelOnly)
+                        {
+                            match = matches.SingleOrDefault(item => item.DeclarationType.HasFlag(DeclarationType.Member));
+                        }
+
                         // ambiguous (?), or no match - make the module be the current selection
-                        var match = AllUserDeclarations.SingleOrDefault(item =>
+                        match = match ?? AllUserDeclarations.SingleOrDefault(item =>
                                     (item.DeclarationType == DeclarationType.Class || item.DeclarationType == DeclarationType.Module)
                                     && item.QualifiedName.QualifiedModuleName.Equals(selection.QualifiedName));
+
                         _selectedDeclaration = match;
                     }
                 }
diff --git a/Rubberduck.VBEEditor/QualifiedModuleName.cs b/Rubberduck.VBEEditor/QualifiedModuleName.cs
@@ -103,7 +103,7 @@ public override string ToString()
         {
             return _component == null && string.IsNullOrEmpty(_projectName)
                 ? string.Empty
-                : (string.IsNullOrEmpty(_projectPath) ? string.Empty : _projectPath + ";") 
+                : (string.IsNullOrEmpty(_projectPath) ? string.Empty : System.IO.Path.GetFileName(_projectPath) + ";")
                      + _projectName + "." + _componentName;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -92,10 +92,11 @@ public IEnumerable<Declaration> MatchName(string name)`
`92`	`92`	`{`
`93`	`93`	`return result;`
`94`	`94`	`}`
	`95`	`+`
`95`	`96`	`return new List<Declaration>();`
`96`	`97`	`}`
`97`	`98`
`98`		`- public Declaration FindProject(Declaration currentScope, string name)`
	`99`	`+ public Declaration FindProject(string name, Declaration currentScope = null)`
`99`	`100`	`{`
`100`	`101`	`Declaration result = null;`
`101`	`102`	`try`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ private Declaration ResolveType(VBAParser.ComplexTypeContext context)`
`204`	`204`	`private Declaration ResolveType(IList<VBAParser.AmbiguousIdentifierContext> identifiers)`
`205`	`205`	`{`
`206`	`206`	`var first = identifiers[0].GetText();`
`207`		`- var projectMatch = _declarationFinder.FindProject(_currentScope, first);`
	`207`	`+ var projectMatch = _declarationFinder.FindProject(first, _currentScope);`
`208`	`208`
`209`	`209`	`if (projectMatch != null)`
`210`	`210`	`{`
`@@ -1109,7 +1109,7 @@ private Declaration FindModuleScopeDeclaration(string identifierName, Declaratio`
`1109`	`1109`	`.ToList();`
`1110`	`1110`	`}`
`1111`	`1111`
`1112`		`- return result.Count == 1 ? result.SingleOrDefault() : null;`
	`1112`	`+ return result.Count == 1 ? result.SingleOrDefault() : null; // return null for multiple matches`
`1113`	`1113`	`}`
`1114`	`1114`
`1115`	`1115`	`private bool IsLocalEvent(Declaration item, Declaration localScope)`
Original file line number	Diff line number	Diff line change
`@@ -235,8 +235,7 @@ private ParserState EvaluateParserState()`
`235`	`235`	`if (moduleStates.Any(module => module != ParserState.Ready))`
`236`	`236`	`{`
`237`	`237`	`// now any module not ready means at least one of them has work in progress;`
`238`		`- // report the least advanced of them, except if that's 'Pending':`
`239`		`- return moduleStates.Except(new[]{ParserState.Pending}).Min();`
	`238`	`+ return moduleStates.Min();`
`240`	`239`	`}`
`241`	`240`
`242`	`241`	`return default(ParserState); // default value is 'Pending'.`
`@@ -560,7 +559,7 @@ public bool IsNewOrModified(QualifiedModuleName key)`
`560`	`559`	`private QualifiedSelection _lastSelection;`
`561`	`560`	`private Declaration _selectedDeclaration;`
`562`	`561`
`563`		`- public Declaration FindSelectedDeclaration(CodePane activeCodePane)`
	`562`	`+ public Declaration FindSelectedDeclaration(CodePane activeCodePane, bool procedureLevelOnly = false)`
`564`	`563`	`{`
`565`	`564`	`var selection = activeCodePane.GetSelection();`
`566`	`565`	`if (selection.Equals(_lastSelection))`
`@@ -588,10 +587,17 @@ public Declaration FindSelectedDeclaration(CodePane activeCodePane)`
`588`	`587`	`}`
`589`	`588`	`else`
`590`	`589`	`{`
	`590`	`+ Declaration match = null;`
	`591`	`+ if (procedureLevelOnly)`
	`592`	`+ {`
	`593`	`+ match = matches.SingleOrDefault(item => item.DeclarationType.HasFlag(DeclarationType.Member));`
	`594`	`+ }`
	`595`	`+`
`591`	`596`	`// ambiguous (?), or no match - make the module be the current selection`
`592`		`- var match = AllUserDeclarations.SingleOrDefault(item =>`
	`597`	`+ match = match ?? AllUserDeclarations.SingleOrDefault(item =>`
`593`	`598`	`(item.DeclarationType == DeclarationType.Class \|\| item.DeclarationType == DeclarationType.Module)`
`594`	`599`	`&& item.QualifiedName.QualifiedModuleName.Equals(selection.QualifiedName));`
	`600`	`+`
`595`	`601`	`_selectedDeclaration = match;`
`596`	`602`	`}`
`597`	`603`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ public override string ToString()`
`103`	`103`	`{`
`104`	`104`	`return _component == null && string.IsNullOrEmpty(_projectName)`
`105`	`105`	`? string.Empty`
`106`		`- : (string.IsNullOrEmpty(_projectPath) ? string.Empty : _projectPath + ";")`
	`106`	`+ : (string.IsNullOrEmpty(_projectPath) ? string.Empty : System.IO.Path.GetFileName(_projectPath) + ";")`
`107`	`107`	`+ _projectName + "." + _componentName;`
`108`	`108`	`}`
`109`	`109`