Consolidate ValueTypes lists, add LongPtr to list, closes #2645

comintern · comintern · commit f0f4183d66f4 · 2017-02-06T18:29:39.000-06:00
diff --git a/RetailCoder.VBE/Inspections/ObjectVariableNotSetInspection.cs b/RetailCoder.VBE/Inspections/ObjectVariableNotSetInspection.cs
@@ -3,6 +3,7 @@
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Resources;
 using Rubberduck.Inspections.Results;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
@@ -20,29 +21,13 @@ public ObjectVariableNotSetInspection(RubberduckParserState state)
         public override string Description { get { return InspectionsUI.ObjectVariableNotSetInspectionName; } }
         public override CodeInspectionType InspectionType { get { return CodeInspectionType.CodeQualityIssues; } }
 
-        private static readonly IReadOnlyList<string> ValueTypes = new[]
-        {
-            Tokens.Boolean,
-            Tokens.Byte,
-            Tokens.Currency,
-            Tokens.Date,
-            Tokens.Decimal,
-            Tokens.Double,
-            Tokens.Integer,
-            Tokens.Long,
-            Tokens.LongLong,
-            Tokens.Single,
-            Tokens.String,
-            Tokens.Variant
-        };
-
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             var interestingDeclarations =
                 State.AllUserDeclarations.Where(item =>
                         !item.IsSelfAssigned &&
                         !item.IsArray &&
-                        !ValueTypes.Contains(item.AsTypeName) &&
+                        !SymbolList.ValueTypes.Contains(item.AsTypeName) &&
                         (item.AsTypeDeclaration == null || (!ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration) &&
                         item.AsTypeDeclaration.DeclarationType != DeclarationType.Enumeration &&
                         item.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType)) &&
@@ -54,7 +39,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                     (item.DeclarationType == DeclarationType.Function || item.DeclarationType == DeclarationType.PropertyGet)
                     && !item.IsArray
                     && item.IsTypeSpecified
-                    && !ValueTypes.Contains(item.AsTypeName) 
+                    && !SymbolList.ValueTypes.Contains(item.AsTypeName) 
                     && (item.AsTypeDeclaration == null // null if unresolved (e.g. in unit tests)
                         || (item.AsTypeDeclaration.DeclarationType != DeclarationType.Enumeration && item.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType 
                             && item.AsTypeDeclaration != null 
diff --git a/RetailCoder.VBE/Inspections/QuickFixes/RemoveTypeHintsQuickFix.cs b/RetailCoder.VBE/Inspections/QuickFixes/RemoveTypeHintsQuickFix.cs
@@ -2,6 +2,7 @@
 using Antlr4.Runtime;
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.Resources;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Grammar;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.VBEditor;
@@ -47,7 +48,7 @@ private void FixTypeHintUsage(string hint, ICodeModule module, Selection selecti
         {
             var line = module.GetLines(selection.StartLine, 1);
 
-            var asTypeClause = ' ' + Tokens.As + ' ' + Declaration.TypeHintToTypeName[hint];
+            var asTypeClause = ' ' + Tokens.As + ' ' + SymbolList.TypeHintToTypeName[hint];
 
             string fix;
 
diff --git a/RetailCoder.VBE/Inspections/SelfAssignedDeclarationInspection.cs b/RetailCoder.VBE/Inspections/SelfAssignedDeclarationInspection.cs
@@ -3,7 +3,7 @@
 using Rubberduck.Inspections.Abstract;
 using Rubberduck.Inspections.QuickFixes;
 using Rubberduck.Inspections.Resources;
-using Rubberduck.Parsing.Grammar;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Parsing.Symbols;
 
@@ -20,27 +20,12 @@ public SelfAssignedDeclarationInspection(RubberduckParserState state)
         public override string Description { get { return InspectionsUI.SelfAssignedDeclarationInspectionName; } }
         public override CodeInspectionType InspectionType { get { return CodeInspectionType.CodeQualityIssues; } }
 
-        private static readonly IReadOnlyList<string> ValueTypes = new[]
-        {
-            Tokens.Boolean,
-            Tokens.Byte,
-            Tokens.Currency,
-            Tokens.Date,
-            Tokens.Decimal,
-            Tokens.Double,
-            Tokens.Integer,
-            Tokens.Long,
-            Tokens.LongLong,
-            Tokens.Single,
-            Tokens.String
-        };
-
         public override IEnumerable<InspectionResultBase> GetInspectionResults()
         {
             return UserDeclarations
                 .Where(declaration => declaration.IsSelfAssigned 
                     && declaration.IsTypeSpecified
-                    && !ValueTypes.Contains(declaration.AsTypeName)
+                    && !SymbolList.ValueTypes.Contains(declaration.AsTypeName)
                     && declaration.DeclarationType == DeclarationType.Variable
                     && (declaration.AsTypeDeclaration == null
                         || declaration.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType)
diff --git a/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs b/RetailCoder.VBE/Navigation/CodeExplorer/CodeExplorerViewModel.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using NLog;
 using Rubberduck.Navigation.Folders;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Annotations;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
@@ -201,7 +202,7 @@ public string PanelTitle
                 }
 
                 var typeName = declaration.HasTypeHint
-                    ? Declaration.TypeHintToTypeName[declaration.TypeHint]
+                    ? SymbolList.TypeHintToTypeName[declaration.TypeHint]
                     : declaration.AsTypeName;
 
                 return nameWithDeclarationType + ": " + typeName;
diff --git a/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodPresenter.cs b/RetailCoder.VBE/Refactorings/ExtractMethod/ExtractMethodPresenter.cs
@@ -1,8 +1,6 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Forms;
-using Rubberduck.Parsing.Grammar;
 using Rubberduck.SmartIndenter;
 
 namespace Rubberduck.Refactorings.ExtractMethod
@@ -59,21 +57,6 @@ private void PrepareView(IExtractMethodModel extractedMethodModel, IExtractMetho
             _view.OnRefreshPreview();
         }
 
-        private static readonly IEnumerable<string> ValueTypes = new[]
-        {
-            Tokens.Boolean,
-            Tokens.Byte,
-            Tokens.Currency,
-            Tokens.Date,
-            Tokens.Decimal,
-            Tokens.Double,
-            Tokens.Integer,
-            Tokens.Long,
-            Tokens.LongLong,
-            Tokens.Single,
-            Tokens.String
-        };
-
         private void GeneratePreview(IExtractMethodModel extractMethodModel,IExtractMethodProc extractMethodProc )
         {
             extractMethodModel.Method.MethodName = _view.MethodName;
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs b/RetailCoder.VBE/UI/Command/MenuItems/CommandBars/IContextFormatter.cs
@@ -1,4 +1,5 @@
 using System.Linq;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
@@ -39,7 +40,7 @@ private string Format(Declaration declaration)
             var formattedDeclaration = string.Empty;
             var moduleName = declaration.QualifiedName.QualifiedModuleName;
             var typeName = declaration.HasTypeHint
-                ? Declaration.TypeHintToTypeName[declaration.TypeHint]
+                ? SymbolList.TypeHintToTypeName[declaration.TypeHint]
                 : declaration.AsTypeName;
             var declarationType = RubberduckUI.ResourceManager.GetString("DeclarationType_" + declaration.DeclarationType, Settings.Settings.Culture);
 
diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -145,6 +145,7 @@
     <Compile Include="ComReflection\ComMember.cs" />
     <Compile Include="ComReflection\ComModule.cs" />
     <Compile Include="ComReflection\ComProject.cs" />
+    <Compile Include="SymbolList.cs" />
     <Compile Include="Symbols\DeclarationLoaders\SpecialFormDeclarations.cs" />
     <Compile Include="Symbols\CommentNode.cs" />
     <Compile Include="ComReflection\ComParameter.cs" />
diff --git a/Rubberduck.Parsing/SymbolList.cs b/Rubberduck.Parsing/SymbolList.cs
@@ -0,0 +1,56 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Rubberduck.Parsing.Grammar;
+
+namespace Rubberduck.Parsing
+{
+    public static class SymbolList
+    {
+        public static readonly IReadOnlyList<string> ValueTypes = new[]
+        {
+            Tokens.Boolean,
+            Tokens.Byte,
+            Tokens.Currency,
+            Tokens.Date,
+            Tokens.Decimal,
+            Tokens.Double,
+            Tokens.Integer,
+            Tokens.Long,
+            Tokens.LongLong,
+            Tokens.LongPtr,
+            Tokens.Single,
+            Tokens.String,
+            Tokens.Variant,            
+        };
+
+        public static readonly IReadOnlyList<string> ValueTypesUpper = new[]
+        {
+            Tokens.Boolean.ToUpper(),
+            Tokens.Byte.ToUpper(),
+            Tokens.Currency.ToUpper(),
+            Tokens.Date.ToUpper(),
+            Tokens.Decimal.ToUpper(),
+            Tokens.Double.ToUpper(),
+            Tokens.Integer.ToUpper(),
+            Tokens.Long.ToUpper(),
+            Tokens.LongLong.ToUpper(),
+            Tokens.LongPtr.ToUpper(),
+            Tokens.Single.ToUpper(),
+            Tokens.String.ToUpper(),
+            Tokens.Variant   
+        };
+
+        public static readonly IDictionary<string, string> TypeHintToTypeName = new Dictionary<string, string>
+        {
+            { "%", Tokens.Integer },
+            { "&", Tokens.Long },
+            { "@", Tokens.Decimal },
+            { "!", Tokens.Single },
+            { "#", Tokens.Double },
+            { "$", Tokens.String }
+        };
+    }
+}
diff --git a/Rubberduck.Parsing/Symbols/Declaration.cs b/Rubberduck.Parsing/Symbols/Declaration.cs
@@ -19,34 +19,6 @@ namespace Rubberduck.Parsing.Symbols
     [DebuggerDisplay("({DeclarationType}) {Accessibility} {IdentifierName} As {AsTypeName} | {Selection}")]
     public class Declaration : IEquatable<Declaration>
     {
-        public static readonly string[] BaseTypes =
-        {
-                "BOOLEAN",
-                "BYTE",
-                "CURRENCY",
-                "DATE",
-                "DOUBLE",
-                "INTEGER",
-                "LONG",
-                "LONGLONG",
-                "LONGPTR",
-                "SINGLE",
-                "STRING",
-                "VARIANT",
-                "OBJECT",
-                "ANY"
-        };
-
-        public static readonly IDictionary<string, string> TypeHintToTypeName = new Dictionary<string, string>
-        {
-            { "%", Tokens.Integer },
-            { "&", Tokens.Long },
-            { "@", Tokens.Decimal },
-            { "!", Tokens.Single },
-            { "#", Tokens.Double },
-            { "$", Tokens.String }
-        };
-
         public Declaration(
             QualifiedMemberName qualifiedName,
             Declaration parentDeclaration,
@@ -485,7 +457,7 @@ public bool AsTypeIsBaseType
         {
             get
             {
-                return string.IsNullOrWhiteSpace(AsTypeName) || BaseTypes.Contains(_asTypeName.ToUpperInvariant());
+                return string.IsNullOrWhiteSpace(AsTypeName) || SymbolList.ValueTypesUpper.Contains(_asTypeName.ToUpperInvariant());
             }
         }
 
diff --git a/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs b/Rubberduck.Parsing/Symbols/TypeAnnotationPass.cs
@@ -52,7 +52,7 @@ private void AnnotateType(Declaration declaration)
                 var typeContext = declaration.AsTypeContext;
                 typeExpression = typeContext.type().complexType().GetText();
             }
-            else if (!string.IsNullOrWhiteSpace(declaration.AsTypeNameWithoutArrayDesignator) && !Declaration.BaseTypes.Contains(declaration.AsTypeNameWithoutArrayDesignator.ToUpperInvariant()))
+            else if (!string.IsNullOrWhiteSpace(declaration.AsTypeNameWithoutArrayDesignator) && !SymbolList.ValueTypesUpper.Contains(declaration.AsTypeNameWithoutArrayDesignator.ToUpperInvariant()))
             {
                 typeExpression = declaration.AsTypeNameWithoutArrayDesignator;
             }
diff --git a/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs b/RubberduckTests/Inspections/ObjectVariableNotSetInpsectionTests.cs
@@ -338,5 +338,32 @@ End Property
             }
             Assert.AreEqual(expectedCode, module.Content());
         }
+
+        [TestMethod]
+        [TestCategory("Inspections")]
+        public void ObjectVariableNotSet_LongPtrVariable_ReturnsNoResult()
+        {
+            const string inputCode = @"
+Private Sub TestLongPtr()
+    Dim handle as LongPtr
+    handle = 123456
+End Sub";
+
+            //Arrange
+            var builder = new MockVbeBuilder();
+            IVBComponent component;
+            var vbe = builder.BuildFromSingleStandardModule(inputCode, out component);
+            var mockHost = new Mock<IHostApplication>();
+            mockHost.SetupAllProperties();
+            var parser = MockParser.Create(vbe.Object, new RubberduckParserState(new Mock<ISinks>().Object));
+
+            parser.Parse(new CancellationTokenSource());
+            if (parser.State.Status >= ParserState.Error) { Assert.Inconclusive("Parser Error"); }
+
+            var inspection = new ObjectVariableNotSetInspection(parser.State);
+            var inspectionResults = inspection.GetInspectionResults();
+
+            Assert.AreEqual(0, inspectionResults.Count());
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ private void AnnotateType(Declaration declaration)`
`52`	`52`	`var typeContext = declaration.AsTypeContext;`
`53`	`53`	`typeExpression = typeContext.type().complexType().GetText();`
`54`	`54`	`}`
`55`		`- else if (!string.IsNullOrWhiteSpace(declaration.AsTypeNameWithoutArrayDesignator) && !Declaration.BaseTypes.Contains(declaration.AsTypeNameWithoutArrayDesignator.ToUpperInvariant()))`
	`55`	`+ else if (!string.IsNullOrWhiteSpace(declaration.AsTypeNameWithoutArrayDesignator) && !SymbolList.ValueTypesUpper.Contains(declaration.AsTypeNameWithoutArrayDesignator.ToUpperInvariant()))`
`56`	`56`	`{`
`57`	`57`	`typeExpression = declaration.AsTypeNameWithoutArrayDesignator;`
`58`	`58`	`}`