Merge pull request #2658 from comintern/next

retailcoder · web-flow · commit 6d652422983a · 2017-02-07T22:04:10.000-05:00
Finish first class support of TYPEKIND.TKIND_ALIAS. *Now* closes #2538
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs b/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs
@@ -84,6 +84,12 @@ private string Format(Declaration declaration)
                     declaration.IdentifierName,
                     typeName);
             }
+            else if (declaration.DeclarationType == DeclarationType.ComAlias)
+            {
+                formattedDeclaration = string.Format("{0};{1}.{2} (alias:{3})",
+                    System.IO.Path.GetFileName(moduleName.ProjectPath), moduleName.ProjectName,
+                    declaration.IdentifierName, declaration.AsTypeName);
+            }
 
             var subscripts = declaration.IsArray ? "()" : string.Empty;
             if (declaration.ParentDeclaration != null && declaration.ParentDeclaration.DeclarationType.HasFlag(DeclarationType.Member))
diff --git a/RetailCoder.VBE/VersionCheck/IVersionCheck.cs b/RetailCoder.VBE/VersionCheck/IVersionCheck.cs
@@ -26,15 +26,22 @@ public VersionCheck()
         {
             if (_latestVersion != default(Version)) { return _latestVersion; }
 
-            using (var client = new HttpClient())
+            try
             {
-                var url = new Uri("http://rubberduckvba.com/Build/Version/Stable");
-                var response = await client.GetAsync(url, token);
-                var content = await response.Content.ReadAsStringAsync();
-                var doc = new HtmlAgilityPack.HtmlDocument();
-                doc.LoadHtml(content);
-                var version = doc.DocumentNode.Descendants("body").Single().InnerText.Trim();
-                return _latestVersion = new Version(version);
+                using (var client = new HttpClient())
+                {
+                    var url = new Uri("http://rubberduckvba.com/Build/Version/Stable");
+                    var response = await client.GetAsync(url, token);
+                    var content = await response.Content.ReadAsStringAsync();
+                    var doc = new HtmlAgilityPack.HtmlDocument();
+                    doc.LoadHtml(content);
+                    var version = doc.DocumentNode.Descendants("body").Single().InnerText.Trim();
+                    return _latestVersion = new Version(version);
+                }
+            }
+            catch
+            {
+                return _latestVersion;
             }
         }
 
diff --git a/Rubberduck.Parsing/Binding/SimpleNameTypeBinding.cs b/Rubberduck.Parsing/Binding/SimpleNameTypeBinding.cs
@@ -205,6 +205,11 @@ procedural module or class module within a referenced project.
             {
                 return new SimpleNameExpression(referencedProjectEnumType, ExpressionClassification.Type, _expression);
             }
+            var referencedProjectAliasType = _declarationFinder.FindMemberReferencedProject(_project, _module, _parent, name, DeclarationType.ComAlias);
+            if (referencedProjectAliasType != null)
+            {
+                return new SimpleNameExpression(referencedProjectAliasType, ExpressionClassification.Type, _expression);
+            }
             return null;
         }
     }
diff --git a/Rubberduck.Parsing/ComReflection/ComAlias.cs b/Rubberduck.Parsing/ComReflection/ComAlias.cs
@@ -1,34 +1,45 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using System.Runtime.InteropServices;
 using System.Runtime.InteropServices.ComTypes;
-using System.Security.Permissions;
-using System.Text;
-using System.Threading.Tasks;
 using TYPEATTR = System.Runtime.InteropServices.ComTypes.TYPEATTR;
+using TYPEFLAGS = System.Runtime.InteropServices.ComTypes.TYPEFLAGS;
 
 namespace Rubberduck.Parsing.ComReflection
 {
+    [DebuggerDisplay("{Name} As {TypeName}")]
     public class ComAlias : ComBase
     {
-        public VarEnum VarType { get; set; }
-
-        public string TypeName { get; set; }
+        public VarEnum VarType { get; private set; }
+        public string TypeName { get; private set; }
+        public bool IsHidden { get; private set; }
+        public bool IsRestricted { get; private set; }
 
         public ComAlias(ITypeLib typeLib, ITypeInfo info, int index, TYPEATTR attributes) : base(typeLib, index)
         {
             Index = index;
             Documentation = new ComDocumentation(typeLib, index);
+            Guid = attributes.guid;
             VarType = (VarEnum)attributes.tdescAlias.vt;
+            IsHidden = attributes.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FHIDDEN);
+            IsRestricted = attributes.wTypeFlags.HasFlag(TYPEFLAGS.TYPEFLAG_FRESTRICTED);
+            
+            if (Name.Equals("LONG_PTR"))
+            {
+                TypeName = "LongPtr";
+                return;                
+            }
+          
             if (ComVariant.TypeNames.ContainsKey(VarType))
             {
                 TypeName = ComVariant.TypeNames[VarType];
             }
             else if (VarType == VarEnum.VT_USERDEFINED)
             {
-                //?
+                ITypeInfo refType;
+                info.GetRefTypeInfo((int)attributes.tdescAlias.lpValue, out refType);
+                var doc = new ComDocumentation(refType, -1);
+                TypeName = doc.Name;
             }
             else
             {
diff --git a/Rubberduck.Parsing/ComReflection/ComDocumentation.cs b/Rubberduck.Parsing/ComReflection/ComDocumentation.cs
@@ -36,7 +36,7 @@ private void LoadDocumentation(ITypeLib typeLib, ITypeInfo info, int index)
             }
 
             //See http://chat.stackexchange.com/transcript/message/30119269#30119269
-            Name = name.Equals("LONG_PTR") ? "LongPtr" : name;
+            Name = name;
             DocString = docString;
             HelpContext = helpContext;
             HelpFile = helpFile;            
diff --git a/Rubberduck.Parsing/ComReflection/ComProject.cs b/Rubberduck.Parsing/ComReflection/ComProject.cs
@@ -125,7 +125,6 @@ private void LoadModules(ITypeLib typeLibrary)
                             _classes.Add(coclass as ComCoClass);
                             if (type != null) KnownTypes.TryAdd(typeAttributes.guid, coclass);
                             break;
-                        case TYPEKIND.TKIND_ALIAS:
                         case TYPEKIND.TKIND_DISPATCH:
                         case TYPEKIND.TKIND_INTERFACE:
                             var intface = type ?? new ComInterface(typeLibrary, info, typeAttributes, index);
@@ -141,11 +140,10 @@ private void LoadModules(ITypeLib typeLibrary)
                             _modules.Add(module as ComModule);
                             if (type != null) KnownTypes.TryAdd(typeAttributes.guid, module);
                             break;
-                        //case TYPEKIND.TKIND_ALIAS:
-                        //    //TKIND_ALIAS does not appear to be a supported member type in VBA - cache it internally to use the aliased type.
-                        //    var alias = new ComAlias(typeLibrary, info, index, typeAttributes);
-                        //    _aliases.Add(alias);
-                        //    break;
+                        case TYPEKIND.TKIND_ALIAS:
+                            var alias = new ComAlias(typeLibrary, info, index, typeAttributes);
+                            _aliases.Add(alias);
+                            break;
                         case TYPEKIND.TKIND_UNION:
                             //TKIND_UNION is not a supported member type in VBA.
                             break;
diff --git a/Rubberduck.Parsing/ComReflection/ComVariant.cs b/Rubberduck.Parsing/ComReflection/ComVariant.cs
@@ -13,6 +13,7 @@ public class ComVariant
             {VarEnum.VT_DISPATCH, Tokens.Object},
             {VarEnum.VT_VOID, string.Empty},
             {VarEnum.VT_VARIANT, Tokens.Variant},
+            {VarEnum.VT_UNKNOWN, Tokens.Object},
             {VarEnum.VT_BLOB_OBJECT, Tokens.Object},
             {VarEnum.VT_STORED_OBJECT, Tokens.Object},
             {VarEnum.VT_STREAMED_OBJECT, Tokens.Object},
@@ -35,7 +36,7 @@ public class ComVariant
             {VarEnum.VT_DECIMAL, Tokens.Decimal},
             {VarEnum.VT_EMPTY, Tokens.Empty},
             {VarEnum.VT_R4, Tokens.Single},
-            {VarEnum.VT_R8, Tokens.Double},
+            {VarEnum.VT_R8, Tokens.Double}
         };
 
 
diff --git a/Rubberduck.Parsing/ComReflection/ReferencedDeclarationsCollector.cs b/Rubberduck.Parsing/ComReflection/ReferencedDeclarationsCollector.cs
@@ -132,6 +132,12 @@ public List<Declaration> LoadDeclarationsFromLibrary()
             _serialized = new SerializableProject(project);
             _declarations.Add(project);
 
+            foreach (var alias in type.Aliases.Select(item => new AliasDeclaration(item, project, projectName)))
+            {
+                _declarations.Add(alias);
+                _serialized.AddDeclaration(new SerializableDeclarationTree(alias));
+            }
+
             foreach (var module in type.Members)
             {
                 var moduleName = new QualifiedModuleName(_referenceName, _path,
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -147,6 +147,7 @@
     <Compile Include="ComReflection\ComModule.cs" />
     <Compile Include="ComReflection\ComProject.cs" />
     <Compile Include="SymbolList.cs" />
+    <Compile Include="Symbols\AliasDeclaration.cs" />
     <Compile Include="Symbols\DeclarationLoaders\SpecialFormDeclarations.cs" />
     <Compile Include="Symbols\CommentNode.cs" />
     <Compile Include="ComReflection\ComParameter.cs" />
diff --git a/Rubberduck.Parsing/Symbols/AccessibilityCheck.cs b/Rubberduck.Parsing/Symbols/AccessibilityCheck.cs
@@ -45,10 +45,15 @@ public static bool IsMemberAccessible(Declaration callingProject, Declaration ca
             {
                 return true;
             }
+            if (calleeMember.IsBuiltIn && calleeMember.Accessibility > Accessibility.Friend)
+            {
+                return true;
+            }
             var memberModule = Declaration.GetModuleParent(calleeMember);
             return IsModuleAccessible(callingProject, callingModule, memberModule)
                     && (calleeMember.DeclarationType.HasFlag(DeclarationType.EnumerationMember)
                         || calleeMember.DeclarationType.HasFlag(DeclarationType.UserDefinedTypeMember)
+                        || calleeMember.DeclarationType.HasFlag(DeclarationType.ComAlias)
                         || HasPublicScope(calleeMember)
                         || (IsEnclosingProject(callingProject, memberModule) && IsAccessibleThroughoutTheSameProject(calleeMember)));
         }
diff --git a/Rubberduck.Parsing/Symbols/AliasDeclaration.cs b/Rubberduck.Parsing/Symbols/AliasDeclaration.cs
@@ -0,0 +1,26 @@
+﻿using Rubberduck.Parsing.ComReflection;
+using Rubberduck.VBEditor;
+
+namespace Rubberduck.Parsing.Symbols
+{
+    public class AliasDeclaration : Declaration
+    {
+        public AliasDeclaration(ComAlias alias, Declaration parent, QualifiedModuleName module)
+            : base(
+                module.QualifyMemberName(alias.Name),
+                parent,
+                parent,
+                alias.TypeName,
+                null,
+                false,
+                false,
+                Accessibility.Public,
+                DeclarationType.ComAlias,
+                null,
+                Selection.Home,
+                false,
+                null,
+                true)
+        { }
+    }
+}
diff --git a/Rubberduck.Parsing/Symbols/DeclarationType.cs b/Rubberduck.Parsing/Symbols/DeclarationType.cs
@@ -63,6 +63,8 @@ public enum DeclarationType
         UnresolvedMember = 1 << 26,
         [DebuggerDisplay("BracketedExpression")]
         BracketedExpression = 1 << 27,
+        [DebuggerDisplay("ComAlias")]
+        ComAlias = 1 << 28
     }
 
     public interface IIdentifier { IdentifierNode Identifier { get; } }
diff --git a/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs b/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs
@@ -41,7 +41,9 @@ public void Execute()
 
         private void AnnotateType(Declaration declaration)
         {
-            if (declaration.DeclarationType == DeclarationType.ClassModule || declaration.DeclarationType == DeclarationType.UserDefinedType)
+            if (declaration.DeclarationType == DeclarationType.ClassModule || 
+                declaration.DeclarationType == DeclarationType.UserDefinedType || 
+                declaration.DeclarationType == DeclarationType.ComAlias)
             {
                 declaration.AsTypeDeclaration = declaration;
                 return;

Original file line number	Diff line number	Diff line change
`@@ -205,6 +205,11 @@ procedural module or class module within a referenced project.`
`205`	`205`	`{`
`206`	`206`	`return new SimpleNameExpression(referencedProjectEnumType, ExpressionClassification.Type, _expression);`
`207`	`207`	`}`
	`208`	`+ var referencedProjectAliasType = _declarationFinder.FindMemberReferencedProject(_project, _module, _parent, name, DeclarationType.ComAlias);`
	`209`	`+ if (referencedProjectAliasType != null)`
	`210`	`+ {`
	`211`	`+ return new SimpleNameExpression(referencedProjectAliasType, ExpressionClassification.Type, _expression);`
	`212`	`+ }`
`208`	`213`	`return null;`
`209`	`214`	`}`
`210`	`215`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ private void LoadDocumentation(ITypeLib typeLib, ITypeInfo info, int index)`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`//See http://chat.stackexchange.com/transcript/message/30119269#30119269`
`39`		`- Name = name.Equals("LONG_PTR") ? "LongPtr" : name;`
	`39`	`+ Name = name;`
`40`	`40`	`DocString = docString;`
`41`	`41`	`HelpContext = helpContext;`
`42`	`42`	`HelpFile = helpFile;`
Original file line number	Diff line number	Diff line change
`@@ -45,10 +45,15 @@ public static bool IsMemberAccessible(Declaration callingProject, Declaration ca`
`45`	`45`	`{`
`46`	`46`	`return true;`
`47`	`47`	`}`
	`48`	`+ if (calleeMember.IsBuiltIn && calleeMember.Accessibility > Accessibility.Friend)`
	`49`	`+ {`
	`50`	`+ return true;`
	`51`	`+ }`
`48`	`52`	`var memberModule = Declaration.GetModuleParent(calleeMember);`
`49`	`53`	`return IsModuleAccessible(callingProject, callingModule, memberModule)`
`50`	`54`	`&& (calleeMember.DeclarationType.HasFlag(DeclarationType.EnumerationMember)`
`51`	`55`	`\|\| calleeMember.DeclarationType.HasFlag(DeclarationType.UserDefinedTypeMember)`
	`56`	`+ \|\| calleeMember.DeclarationType.HasFlag(DeclarationType.ComAlias)`
`52`	`57`	`\|\| HasPublicScope(calleeMember)`
`53`	`58`	`\|\| (IsEnclosingProject(callingProject, memberModule) && IsAccessibleThroughoutTheSameProject(calleeMember)));`
`54`	`59`	`}`