protected override IEnumerable <IInspectionResult> DoGetInspectionResults()
        {
            var interestingDeclarations =
                State.AllDeclarations.Where(item =>
                                            item.AsTypeDeclaration != null &&
                                            ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration));

            var interestingReferences = interestingDeclarations
                                        .SelectMany(declaration => declaration.References)
                                        .Where(reference =>
            {
                var letStmtContext = reference.Context.GetAncestor <VBAParser.LetStmtContext>();
                return(reference.IsAssignment &&
                       letStmtContext != null &&
                       letStmtContext.LET() == null &&
                       !reference.IsIgnoringInspectionResultFor(AnnotationName));
            });

            return(interestingReferences.Select(reference => new IdentifierReferenceInspectionResult(this,
                                                                                                     string.Format(InspectionResults.ImplicitDefaultMemberAssignmentInspection,
                                                                                                                   reference.Declaration.IdentifierName,
                                                                                                                   reference.Declaration.AsTypeDeclaration.IdentifierName),
                                                                                                     State,
                                                                                                     reference)));
        }
        private static Declaration GetNewClassDeclaration(Declaration project, string name, IEnumerable <IAnnotation> annotations)
        {
            var declaration =
                new ClassModuleDeclaration(new QualifiedMemberName(project.QualifiedModuleName, name), project, name, true, annotations, new Attributes());

            return(declaration);
        }
示例#3
0
        public void Refactor(QualifiedSelection selection)
        {
            _targetInterface = _state.DeclarationFinder.FindInterface(selection);

            _targetClass = _declarations.SingleOrDefault(d =>
                                                         ImplementingModuleTypes.Contains(d.DeclarationType) &&
                                                         d.QualifiedSelection.QualifiedName.Equals(selection.QualifiedName)) as ClassModuleDeclaration;

            if (_targetClass == null || _targetInterface == null)
            {
                _messageBox.NotifyWarn(RubberduckUI.ImplementInterface_InvalidSelectionMessage, RubberduckUI.ImplementInterface_Caption);
                return;
            }

            var oldSelection = _vbe.GetActiveSelection();

            ImplementMissingMembers(_state.GetRewriter(_targetClass));

            if (oldSelection.HasValue)
            {
                using (var module = _state.ProjectsProvider.Component(oldSelection.Value.QualifiedName).CodeModule)
                {
                    using (var pane = module.CodePane)
                    {
                        pane.Selection = oldSelection.Value.Selection;
                    }
                }
            }

            _state.OnParseRequested(this);
        }
        public void GetSupertypesReturnsAnEmptyEnumerableForDeclarationsWithDeclarationTypeClassModuleWhichAreNoClassModuleDeclarations()
        {
            var projectDeclaration = GetTestProject("testProject");
            var fakeClassModule    = GetTestFakeClassModule(projectDeclaration, "testFakeClass");

            Assert.IsFalse(ClassModuleDeclaration.GetSupertypes(fakeClassModule).Any());
        }
        public void GetSupertypesReturnsAnEmptyEnumerableForProceduralModules()
        {
            var projectDeclaration = GetTestProject("testProject");
            var proceduralModule   = GetTestProceduralModule(projectDeclaration, "testModule");

            Assert.IsFalse(ClassModuleDeclaration.GetSupertypes(proceduralModule).Any());
        }
示例#6
0
        private static bool MayRequireAssignmentUsingSet(Declaration declaration)
        {
            if (declaration.DeclarationType == DeclarationType.PropertyLet)
            {
                return(false);
            }

            if (declaration.AsTypeName == Tokens.Variant)
            {
                return(true);
            }

            if (declaration.IsArray)
            {
                return(false);
            }

            if (declaration.AsTypeDeclaration != null)
            {
                if ((ClassModuleDeclaration.HasDefaultMember(declaration.AsTypeDeclaration) ||
                     declaration.AsTypeDeclaration.DeclarationType == DeclarationType.Enumeration))
                {
                    return(false);
                }
            }

            if (SymbolList.ValueTypes.Contains(declaration.AsTypeName))
            {
                return(false);
            }
            return(true);
        }
        private List <Declaration> GetExcelRangeDeclarations()
        {
            var excelDeclaration = new ProjectDeclaration(new QualifiedMemberName(new QualifiedModuleName("Excel",
                                                                                                          "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "Excel"), "Excel"), "Excel", true);

            var globalDeclaration = new ClassModuleDeclaration(new QualifiedMemberName(
                                                                   new QualifiedModuleName("Excel",
                                                                                           "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "_Global"),
                                                                   "_Global"), excelDeclaration, "_Global", true, null, null);

            var globalCoClassDeclarationAttributes = new Attributes();

            globalCoClassDeclarationAttributes.AddPredeclaredIdTypeAttribute();
            globalCoClassDeclarationAttributes.AddGlobalClassAttribute();

            var globalCoClassDeclaration = new ClassModuleDeclaration(new QualifiedMemberName(
                                                                          new QualifiedModuleName("Excel",
                                                                                                  "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "Global"),
                                                                          "Global"), excelDeclaration, "Global", true, null, globalCoClassDeclarationAttributes);

            globalDeclaration.AddSubtype(globalCoClassDeclaration);
            globalCoClassDeclaration.AddSupertype(globalDeclaration);
            globalCoClassDeclaration.AddSupertype("_Global");

            var rangeClassModuleDeclaration = new ClassModuleDeclaration(new QualifiedMemberName(
                                                                             new QualifiedModuleName("Excel",
                                                                                                     "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "Range"),
                                                                             "Range"), excelDeclaration, "Range", true, new List <IAnnotation>(), new Attributes());

            var rangeDeclaration = new PropertyGetDeclaration(new QualifiedMemberName(
                                                                  new QualifiedModuleName("Excel",
                                                                                          "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "_Global"), "Range"),
                                                              globalDeclaration, globalDeclaration, "Range", null, null, Accessibility.Global, null, Selection.Home,
                                                              false, true, new List <IAnnotation>(), new Attributes());

            var firstParamDeclaration = new ParameterDeclaration(new QualifiedMemberName(
                                                                     new QualifiedModuleName("Excel",
                                                                                             "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "_Global"),
                                                                     "Cell1"), rangeDeclaration, "Variant", null, null, false, false);

            var secondParamDeclaration = new ParameterDeclaration(new QualifiedMemberName(
                                                                      new QualifiedModuleName("Excel",
                                                                                              "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "_Global"),
                                                                      "Cell2"), rangeDeclaration, "Variant", null, null, true, false);

            rangeDeclaration.AddParameter(firstParamDeclaration);
            rangeDeclaration.AddParameter(secondParamDeclaration);

            return(new List <Declaration>
            {
                excelDeclaration,
                globalDeclaration,
                globalCoClassDeclaration,
                rangeClassModuleDeclaration,
                rangeDeclaration,
                firstParamDeclaration,
                secondParamDeclaration,
            });
        }
示例#8
0
        public void ReportsRange()
        {
            const string inputCode =
                @"Sub foo()
    Dim arr1() As Variant
    arr1 = Range(""A1:B2"")
End Sub
";

            //Arrange
            var builder = new MockVbeBuilder();
            var project = builder.ProjectBuilder("TestProject1", vbext_ProjectProtection.vbext_pp_none)
                          .AddComponent("Class1", vbext_ComponentType.vbext_ct_ClassModule, inputCode)
                          .AddReference("Excel", string.Empty, true)

                          // Apparently, the COM loader can't find it when it isn't actually loaded...
                          //.AddReference("VBA", "C:\\Program Files\\Common Files\\Microsoft Shared\\VBA\\VBA7.1\\VBE7.DLL", true)
                          .Build();
            var vbe = builder.AddProject(project).Build();

            var mockHost = new Mock <IHostApplication>();

            mockHost.SetupAllProperties();

            var parser = MockParser.Create(vbe.Object, new RubberduckParserState());

            var excelDeclaration = new ProjectDeclaration(new QualifiedMemberName(new QualifiedModuleName("Excel",
                                                                                                          "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "Excel"), "Excel"), "Excel", true);

            var listColumnDeclaration = new ClassModuleDeclaration(new QualifiedMemberName(
                                                                       new QualifiedModuleName("Excel",
                                                                                               "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "ListColumn"),
                                                                       "ListColumn"), excelDeclaration, "ListColumn", true, null, null);

            var rangeDeclaration =
                new Declaration(
                    new QualifiedMemberName(
                        new QualifiedModuleName("Excel",
                                                "C:\\Program Files\\Microsoft Office\\Root\\Office 16\\EXCEL.EXE", "ListColumn"), "Range"),
                    listColumnDeclaration, "EXCEL.EXE;Excel.ListColumn", "Range", null, false, false, Accessibility.Global,
                    (DeclarationType)3712, false, null, true, null, new Attributes());

            parser.State.AddDeclaration(excelDeclaration);
            parser.State.AddDeclaration(listColumnDeclaration);
            parser.State.AddDeclaration(rangeDeclaration);

            parser.Parse();
            if (parser.State.Status >= ParserState.Error)
            {
                Assert.Inconclusive("Parser Error");
            }

            var inspection        = new ImplicitActiveSheetReferenceInspection(vbe.Object, parser.State);
            var inspectionResults = inspection.GetInspectionResults();

            Assert.AreEqual(1, inspectionResults.Count());
        }
        public void GetSupertypesReturnsTheSupertypesOfAClassModule()
        {
            var projectDeclaration = GetTestProject("testProject");
            var supertype          = GetTestClassModule(projectDeclaration, "testSupertype", true, null);
            var classModule        = GetTestClassModule(projectDeclaration, "testClass", true, null);

            classModule.AddSupertype(supertype);

            Assert.AreEqual(supertype, ClassModuleDeclaration.GetSupertypes(classModule).First());
        }
示例#10
0
 private static SubroutineDeclaration DebugPrintDeclaration(ClassModuleDeclaration debugClass)
 {
     return(new SubroutineDeclaration(
                new QualifiedMemberName(debugClass.QualifiedName.QualifiedModuleName, "Print"),
                debugClass,
                debugClass,
                null,
                Accessibility.Global,
                null, Selection.Home,
                true,
                null,
                new Attributes()));
 }
示例#11
0
 private static SubroutineDeclaration DebugAssertDeclaration(ClassModuleDeclaration debugClass)
 {
     return(new SubroutineDeclaration(
                new QualifiedMemberName(debugClass.QualifiedName.QualifiedModuleName, "Assert"),
                debugClass,
                debugClass,
                null,
                Accessibility.Global,
                null,
                Selection.Home,
                false,
                new List <IAnnotation>(),
                new Attributes()));
 }
        public ExtractInterfaceModel(IDeclarationFinderProvider declarationFinderProvider, ClassModuleDeclaration target, ICodeBuilder codeBuilder)
        {
            TargetDeclaration         = target;
            DeclarationFinderProvider = declarationFinderProvider;

            if (TargetDeclaration == null)
            {
                return;
            }

            InterfaceName       = $"I{TargetDeclaration.IdentifierName}";
            InterfaceInstancing = ImplementingClassInstancing;

            LoadMembers(codeBuilder);
        }
示例#13
0
 private static bool IsEnclosingModule(Declaration callingModule, Declaration calleeMember)
 {
     if (callingModule.Equals(calleeMember.ParentScopeDeclaration))
     {
         return(true);
     }
     foreach (var supertype in ClassModuleDeclaration.GetSupertypes(callingModule))
     {
         if (IsEnclosingModule(supertype, calleeMember))
         {
             return(true);
         }
     }
     return(false);
 }
示例#14
0
        private static ClassModuleDeclaration GetHostWorkbookDeclaration(DeclarationFinder finder)
        {
            var documentModuleQMNs        = finder.AllModules.Where(m => m.ComponentType == ComponentType.Document);
            ClassModuleDeclaration result = null;

            foreach (var qmn in documentModuleQMNs)
            {
                var declaration = finder.ModuleDeclaration(qmn) as ClassModuleDeclaration;
                if (declaration.Supertypes.Any(t => t.IdentifierName.Equals("Workbook") && t.ProjectName == "Excel" && !t.IsUserDefined))
                {
                    result = declaration;
                    break;
                }
            }

            return(result ?? throw new System.InvalidOperationException("Failed to find the host Workbook declaration."));
        }
        public override IEnumerable <InspectionResultBase> GetInspectionResults()
        {
            var interestingDeclarations =
                State.AllDeclarations.Where(item =>
                                            item.AsTypeDeclaration != null &&
                                            ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration));

            var interestingReferences = interestingDeclarations
                                        .SelectMany(declaration => declaration.References)
                                        .Where(reference =>
            {
                var letStmtContext = ParserRuleContextHelper.GetParent <VBAParser.LetStmtContext>(reference.Context);
                return(reference.IsAssignment && letStmtContext != null && letStmtContext.LET() == null);
            });

            return(interestingReferences.Select(reference => new ImplicitDefaultMemberAssignmentInspectionResult(this, reference)));
        }
        public void Refactor(QualifiedSelection selection)
        {
            _targetInterface = _declarationFinderProvider.DeclarationFinder.FindInterface(selection);

            _targetClass = _declarations.SingleOrDefault(d =>
                                                         ImplementingModuleTypes.Contains(d.DeclarationType) &&
                                                         d.QualifiedSelection.QualifiedName.Equals(selection.QualifiedName)) as ClassModuleDeclaration;

            if (_targetClass == null || _targetInterface == null)
            {
                _messageBox.NotifyWarn(RubberduckUI.ImplementInterface_InvalidSelectionMessage, RubberduckUI.ImplementInterface_Caption);
                return;
            }


            var rewriteSession = _rewritingManager.CheckOutCodePaneSession();
            var rewriter       = rewriteSession.CheckOutModuleRewriter(_targetClass.QualifiedModuleName);

            ImplementMissingMembers(rewriter);
            rewriteSession.TryRewrite();
        }
示例#17
0
        private static bool HasPotentiallyNonObjectParameterlessDefaultMember(ClassModuleDeclaration classModule)
        {
            var defaultMember = classModule?.DefaultMember;

            if (defaultMember == null)
            {
                return(false);
            }

            var parameters = (defaultMember as IParameterizedDeclaration)?.Parameters;

            // assign declaration is an object without a default parameterless (or with all parameters optional) member - LHS needs a 'Set' keyword.
            if (parameters != null && parameters.Any(p => !p.IsOptional))
            {
                return(false);
            }

            var defaultMemberType = defaultMember.AsTypeDeclaration as ClassModuleDeclaration;

            return(defaultMemberType == null || HasPotentiallyNonObjectParameterlessDefaultMember(defaultMemberType));
        }
        public override IEnumerable <InspectionResultBase> GetInspectionResults()
        {
            var interestingDeclarations =
                State.AllUserDeclarations.Where(item =>
                                                !item.IsSelfAssigned &&
                                                !item.IsArray &&
                                                !SymbolList.ValueTypes.Contains(item.AsTypeName) &&
                                                (item.AsTypeDeclaration == null || (!ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration) &&
                                                                                    item.AsTypeDeclaration.DeclarationType != DeclarationType.Enumeration &&
                                                                                    item.AsTypeDeclaration.DeclarationType != DeclarationType.UserDefinedType)) &&
                                                (item.DeclarationType == DeclarationType.Variable ||
                                                 item.DeclarationType == DeclarationType.Parameter));

            var interestingMembers =
                State.AllUserDeclarations.Where(item =>
                                                (item.DeclarationType == DeclarationType.Function || item.DeclarationType == DeclarationType.PropertyGet) &&
                                                !item.IsArray &&
                                                item.IsTypeSpecified &&
                                                !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 &&
                                                  !ClassModuleDeclaration.HasDefaultMember(item.AsTypeDeclaration))));

            var interestingReferences = interestingDeclarations
                                        .Union(interestingMembers.SelectMany(item =>
                                                                             item.References.Where(reference => reference.ParentScoping.Equals(item) && reference.IsAssignment)
                                                                             .Select(reference => reference.Declaration)))
                                        .SelectMany(declaration =>
                                                    declaration.References.Where(reference =>
            {
                var letStmtContext = ParserRuleContextHelper.GetParent <VBAParser.LetStmtContext>(reference.Context);
                return(reference.IsAssignment && letStmtContext != null && letStmtContext.LET() == null);
            })
                                                    );


            return(interestingReferences.Select(reference => new ObjectVariableNotSetInspectionResult(this, reference)));
        }
示例#19
0
 public ImplementInterfaceModel(ClassModuleDeclaration targetInterface, ClassModuleDeclaration targetClass)
 {
     TargetInterface = targetInterface;
     TargetClass     = targetClass;
 }
示例#20
0
 private static ImplementInterfaceModel Model(ClassModuleDeclaration targetInterface, ClassModuleDeclaration targetClass)
 {
     return(new ImplementInterfaceModel(targetInterface, targetClass));
 }
示例#21
0
        private IBoundExpression ResolveDefaultMember(IBoundExpression lExpression, string asTypeName, Declaration asTypeDeclaration)
        {
            if (lExpression.ReferencedDeclaration.IsArray)
            {
                return(null);
            }

            /*
             *  The declared type of <l-expression> is Object or Variant, and <argument-list> contains no
             *  named arguments. In this case, the index expression is classified as an unbound member with
             *  a declared type of Variant, referencing <l-expression> with no member name.
             */
            if (
                asTypeName != null &&
                (asTypeName.ToUpperInvariant() == "VARIANT" || asTypeName.ToUpperInvariant() == "OBJECT") &&
                !_argumentList.HasNamedArguments)
            {
                return(new IndexExpression(null, ExpressionClassification.Unbound, _expression, lExpression, _argumentList));
            }

            /*
             *  The declared type of <l-expression> is a specific class, which has a public default Property
             *  Get, Property Let, function or subroutine, and one of the following is true:
             */
            bool hasDefaultMember = asTypeDeclaration != null &&
                                    asTypeDeclaration.DeclarationType == DeclarationType.ClassModule &&
                                    ((ClassModuleDeclaration)asTypeDeclaration).DefaultMember != null;

            if (hasDefaultMember)
            {
                ClassModuleDeclaration classModule     = (ClassModuleDeclaration)asTypeDeclaration;
                Declaration            defaultMember   = classModule.DefaultMember;
                bool isPropertyGetLetFunctionProcedure =
                    defaultMember.DeclarationType == DeclarationType.PropertyGet ||
                    defaultMember.DeclarationType == DeclarationType.PropertyLet ||
                    defaultMember.DeclarationType == DeclarationType.Function ||
                    defaultMember.DeclarationType == DeclarationType.Procedure;
                bool isPublic =
                    defaultMember.Accessibility == Accessibility.Global ||
                    defaultMember.Accessibility == Accessibility.Implicit ||
                    defaultMember.Accessibility == Accessibility.Public;
                if (isPropertyGetLetFunctionProcedure && isPublic)
                {
                    /*
                     *  This default member’s parameter list is compatible with <argument-list>. In this case, the
                     *  index expression references this default member and takes on its classification and
                     *  declared type.
                     *
                     *  TODO: Primitive argument compatibility checking for now.
                     */
                    if (((IParameterizedDeclaration)defaultMember).Parameters.Count() == _argumentList.Arguments.Count)
                    {
                        return(new IndexExpression(defaultMember, lExpression.Classification, _expression, lExpression, _argumentList));
                    }

                    /**
                     *  This default member cannot accept any parameters. In this case, the static analysis restarts
                     *  recursively, as if this default member was specified instead for <l-expression> with the
                     *  same <argument-list>.
                     */
                    if (((IParameterizedDeclaration)defaultMember).Parameters.Count() == 0)
                    {
                        // Recursion limit reached, abort.
                        if (DEFAULT_MEMBER_RECURSION_LIMIT == _defaultMemberRecursionLimitCounter)
                        {
                            return(null);
                        }
                        _defaultMemberRecursionLimitCounter++;
                        ExpressionClassification classification;
                        if (defaultMember.DeclarationType.HasFlag(DeclarationType.Property))
                        {
                            classification = ExpressionClassification.Property;
                        }
                        else if (defaultMember.DeclarationType == DeclarationType.Procedure)
                        {
                            classification = ExpressionClassification.Subroutine;
                        }
                        else
                        {
                            classification = ExpressionClassification.Function;
                        }
                        var defaultMemberAsLExpression = new SimpleNameExpression(defaultMember, classification, _expression);
                        return(Resolve(defaultMemberAsLExpression));
                    }
                }
            }
            return(null);
        }
示例#22
0
 private static bool IsInstanceMemberOfModuleOrOneOfItsSupertypes(Declaration module, Declaration member)
 {
     return(IsInstanceMemberOfModule(module, member) ||
            ClassModuleDeclaration.GetSupertypes(module).Any(supertype => IsInstanceMemberOfModuleOrOneOfItsSupertypes(supertype, member)));         //ClassModuleDeclaration.GetSuperTypes never returns null.
 }