Merge pull request #5739 from retailcoder/translate252

Updating French Translations for v2.5.2

Author: retailcoder

.editorconfig

@@ -0,0 +1,13 @@
+[*.cs]
+
+# CS1584: XML comment has syntactically incorrect cref attribute
+dotnet_diagnostic.CS1584.severity = none
+
+# CS1041: expected identifier, invalid keyword
+dotnet_diagnostic.CS1041.severity = none
+
+# CS1658: Warning is overriding an error
+dotnet_diagnostic.CS1658.severity = none
+
+# IDE0079: Remove unnecessary suppression
+dotnet_diagnostic.IDE0079.severity = none

Rubberduck.CodeAnalysis/Inspections/Concrete/AssignmentNotUsedInspection.cs

@@ -35,6 +35,8 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     ///     value = otherVar * value
     /// End Sub
     /// ]]>
+    /// </module>
+    /// </example>
     /// <example hasResult="true">
     /// <module name="Module1" type="Standard Module">
     /// <![CDATA[
@@ -204,7 +206,7 @@ private static bool TryGetRelevantJumpContext<T>(IdentifierReference resultCandi
 
         private static bool IsPotentiallyUsedAssignment<T>(T jumpContext, IdentifierReference resultCandidate, Dictionary<string, int> labelIdLineNumberPairs) where T : ParserRuleContext
         {
-            int? executionBranchLine = null;
+            int? executionBranchLine;
 
             switch (jumpContext)
             {
@@ -219,9 +221,7 @@ private static bool IsPotentiallyUsedAssignment<T>(T jumpContext, IdentifierRefe
                     break;
             }
 
-            return executionBranchLine.HasValue
-                ?   AssignmentIsUsedPriorToExitStmts(resultCandidate, executionBranchLine.Value)
-                :   false;
+            return executionBranchLine.HasValue && AssignmentIsUsedPriorToExitStmts(resultCandidate, executionBranchLine.Value);
         }
 
         private static bool AssignmentIsUsedPriorToExitStmts(IdentifierReference resultCandidate, int executionBranchLine)

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitActiveSheetReferenceInspection.cs

@@ -9,11 +9,11 @@
 namespace Rubberduck.CodeAnalysis.Inspections.Concrete
 {
     /// <summary>
-    /// Locates unqualified Worksheet.Range/Cells/Columns/Rows member calls inside worksheet modules.
+    /// Locates unqualified Worksheet.Range/Cells/Columns/Rows member calls implicitly referring to ActiveSheet.
     /// </summary>
     /// <reference name="Excel" />
     /// <why>
-    /// Implicit references to the active worksheet rarely mean to be working with *whatever worksheet is currently active*. 
+    /// Implicit references to the active worksheet (ActiveSheet) rarely mean to be working with *whatever worksheet is currently active*. 
     /// By explicitly qualifying these member calls with a specific Worksheet object, the assumptions are removed, the code
     /// is more robust, and will be less likely to throw run-time error 1004 or produce unexpected results
     /// when the active sheet isn't the expected one.

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitContainingWorkbookReferenceInspection.cs

@@ -13,12 +13,12 @@
 namespace Rubberduck.CodeAnalysis.Inspections.Concrete
 {
     /// <summary>
-    /// Locates unqualified Workbook.Worksheets/Sheets/Names member calls inside workbook document modules that implicitly refer to the containing workbook.
+    /// Locates unqualified Workbook.Worksheets/Sheets/Names member calls inside workbook document modules, that implicitly refer to the host workbook.
     /// </summary>
-    /// <reference name="Excel" />
+    /// <hostApp name="Excel" />
     /// <why>
-    /// Implicit references inside a workbook document module can be mistakes for implicit references to the active workbook, which is the behavior in all other modules 
-    /// By explicitly qualifying these member calls with Me, the ambiguity can be resolved.
+    /// Implicit references inside a workbook document module can easily be mistaken for implicit references to the active workbook (ActiveWorkbook), which is the behavior in all other module types.
+    /// By explicitly qualifying these member calls with 'Me', the ambiguity can be resolved. If the intent is to actually refer to the active workbook, qualify with 'ActiveWorkbook' to prevent a bug.
     /// </why>
     /// <example hasResult="true">
     /// <module name="ThisWorkbook" type="Document Module">
@@ -40,7 +40,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// ]]>
     /// </module>
     /// </example>
-    [RequiredLibrary("Excel")]
+    [RequiredHost("Excel")]
     internal sealed class ImplicitContainingWorkbookReferenceInspection : ImplicitWorkbookReferenceInspectionBase
     {
         public ImplicitContainingWorkbookReferenceInspection(IDeclarationFinderProvider declarationFinderProvider)

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitContainingWorksheetReferenceInspection.cs

@@ -10,12 +10,12 @@
 namespace Rubberduck.CodeAnalysis.Inspections.Concrete
 {
     /// <summary>
-    /// Locates unqualified Worksheet.Range/Cells/Columns/Rows member calls inside worksheet modules that implicitly refer to the containing sheet.
+    /// Locates unqualified Worksheet.Range/Cells/Columns/Rows member calls inside worksheet modules, that implicitly refer to the containing sheet component.
     /// </summary>
-    /// <reference name="Excel" />
+    /// <hostApp name="Excel" />
     /// <why>
-    /// Implicit references inside a worksheet document module can be mistakes for implicit references to the active worksheet, which is the behavior in all other places.
-    /// By explicitly qualifying these member calls with Me, the ambiguity can be resolved.
+    /// Implicit references inside a worksheet document module can easily be mistaken for implicit references to the active worksheet (ActiveSheet), which is the behavior in all other module types.
+    /// By explicitly qualifying these member calls with 'Me', the ambiguity can be resolved. If the intent is to refer to the active worksheet, qualify with 'ActiveSheet' to prevent a bug.
     /// </why>
     /// <example hasResult="true">
     /// <module name="Sheet1" type="Document Module">
@@ -37,7 +37,7 @@ namespace Rubberduck.CodeAnalysis.Inspections.Concrete
     /// ]]>
     /// </module>
     /// </example>
-    [RequiredLibrary("Excel")]
+    [RequiredHost("Excel")]
     internal sealed class ImplicitContainingWorksheetReferenceInspection : ImplicitSheetReferenceInspectionBase
     {
         public ImplicitContainingWorksheetReferenceInspection(IDeclarationFinderProvider declarationFinderProvider)

Rubberduck.CodeAnalysis/Inspections/Concrete/InvalidAnnotationInspection.cs

@@ -222,7 +222,7 @@ protected override IEnumerable<IParseTreeAnnotation> GetInvalidAnnotations(
         {
             return GetUnboundAnnotations(annotations, userDeclarations, identifierReferences)
                 .Where(pta => !pta.Annotation.Target.HasFlag(AnnotationTarget.General) || pta.AnnotatedLine == null)
-                .Concat(AttributeAnnotationsOnDeclarationsNotAllowingAttributes(annotations, userDeclarations, identifierReferences))
+                .Concat(AttributeAnnotationsOnDeclarationsNotAllowingAttributes(userDeclarations))
                 .ToList();
         }
 
@@ -241,10 +241,7 @@ private IEnumerable<IParseTreeAnnotation> GetUnboundAnnotations(
                 .Where(pta => pta.Annotation.GetType() != typeof(NotRecognizedAnnotation) && !boundAnnotationsSelections.Contains(pta.QualifiedSelection));
         }
 
-        private IEnumerable<IParseTreeAnnotation> AttributeAnnotationsOnDeclarationsNotAllowingAttributes(
-            IEnumerable<IParseTreeAnnotation> annotations,
-            IEnumerable<Declaration> userDeclarations,
-            IEnumerable<IdentifierReference> identifierReferences)
+        private IEnumerable<IParseTreeAnnotation> AttributeAnnotationsOnDeclarationsNotAllowingAttributes(IEnumerable<Declaration> userDeclarations)
         {
             return userDeclarations
                 .Where(declaration => declaration.AttributesPassContext == null

Rubberduck.CodeAnalysis/Inspections/Concrete/SheetAccessedUsingStringInspection.cs

@@ -193,8 +193,7 @@ private static VBAParser.LiteralExpressionContext SheetNameArgumentLiteralExpres
         private string CodeNameOfVBComponentMatchingSheetName(string projectId, string sheetName)
         {
             var components = _projectsProvider.Components(projectId);
-
-            foreach (var (module, component) in components)
+            foreach (var (_, component) in components)
             {
                 if (component.Type != ComponentType.Document)
                 {

Rubberduck.CodeAnalysis/Inspections/Concrete/UnreachableCaseEvaluation/FilterLimits.cs

@@ -36,9 +36,9 @@ internal struct Limit<T> where T : IComparable<T>
 
         public static bool operator !=(Limit<T> LHS, Limit<T> RHS) => !(LHS == RHS);
 
-        public static bool operator >(Limit<T> LHS, T RHS) => LHS.HasValue ? LHS.Value.CompareTo(RHS) > 0 : false;
+        public static bool operator >(Limit<T> LHS, T RHS) => LHS.HasValue && LHS.Value.CompareTo(RHS) > 0;
 
-        public static bool operator <(Limit<T> LHS, T RHS) => LHS.HasValue? LHS.Value.CompareTo(RHS) < 0 : false;
+        public static bool operator <(Limit<T> LHS, T RHS) => LHS.HasValue && LHS.Value.CompareTo(RHS) < 0;
 
         public static bool operator >=(Limit<T> LHS, Limit<T> RHS) => LHS == RHS || LHS > RHS;
 
@@ -106,7 +106,7 @@ public void SetExtents(T min, T max)
 
         public bool SetMinimum(T min)
         {
-            var setNewValue = false;
+            bool setNewValue;
             if (_min.HasValue)
             {
                 setNewValue = min.CompareTo(_min.Value) > 0;
@@ -123,7 +123,7 @@ public bool SetMinimum(T min)
 
         public bool SetMaximum(T max)
         {
-            var setNewValue = false;
+            bool setNewValue;
             if (_max.HasValue)
             {
                 setNewValue = max.CompareTo(_max.Value) < 0;
@@ -195,20 +195,22 @@ public override bool Equals(object obj)
             return true;
         }
 
+        public override int GetHashCode() => VBEditor.HashCode.Compute(Minimum, Maximum);
+
         public override string ToString()
         {
             var minString = string.Empty;
             var maxString = string.Empty;
             if (_min.HasValue)
             {
                 minString = MinimumExtent.HasValue && _min == MinimumExtent
-                    ? $"Min(typeMin)" : $"Min({_min.ToString()})";
+                    ? $"Min(typeMin)" : $"Min({_min})";
             }
 
             if (_max.HasValue)
             {
                 maxString = MaximumExtent.HasValue && _max == MaximumExtent
-                    ? $"Max(typeMax)" : $"Max({_max.ToString()})";
+                    ? $"Max(typeMax)" : $"Max({_max})";
             }
             return $"{minString}{maxString}";
         }

Rubberduck.CodeAnalysis/QuickFixes/Concrete/ExpandBangNotationQuickFix.cs

@@ -132,8 +132,8 @@ public override string Description(IInspectionResult result)
         public override bool CanFixInProject => true;
         public override bool CanFixAll => true;
 
-        private string NonIdentifierCharacters = "[](){}\r\n\t.,'\"\\ |!@#$%^&*-+:=; ";
-        private string AdditionalNonFirstIdentifierCharacters = "0123456789_";
+        private readonly string NonIdentifierCharacters = "[](){}\r\n\t.,'\"\\ |!@#$%^&*-+:=; ";
+        private readonly string AdditionalNonFirstIdentifierCharacters = "0123456789_";
 
         private static readonly Dictionary<string, string> DefaultMemberOverrides = new Dictionary<string, string>
         {

Rubberduck.Core/Navigation/CodeExplorer/CodeExplorerMemberViewModel.cs

@@ -51,7 +51,7 @@ public override string NameWithSignature
         }
 
         public override bool IsObsolete =>
-            Declaration.Annotations.Any(annotation => annotation is ObsoleteAnnotation);
+            Declaration.Annotations.Any(pta => pta.Annotation is ObsoleteAnnotation);
 
         public static readonly DeclarationType[] SubMemberTypes =
         {