Core(Tests): introduce DisallowShadowing rule

Added DisallowShadowing rule (no implementation yet). Added
tests for it.

Author: webwarrior-ws

src/FSharpLint.Core/FSharpLint.Core.fsproj

@@ -60,6 +60,7 @@
     <Compile Include="Rules\Conventions\EnsureTailCallDiagnosticsInRecursiveFunctions.fs" />
     <Compile Include="Rules\Conventions\FailwithBadUsage.fs" />
     <Compile Include="Rules\Conventions\FavourSingleton.fs" />
+    <Compile Include="Rules\Conventions\DisallowShadowing.fs" />
     <Compile Include="Rules\Conventions\SourceLength\SourceLengthHelper.fs" />
     <Compile Include="Rules\Conventions\SourceLength\MaxLinesInLambdaFunction.fs" />
     <Compile Include="Rules\Conventions\SourceLength\MaxLinesInMatchLambdaFunction.fs" />

src/FSharpLint.Core/Rules/Conventions/DisallowShadowing.fs

@@ -0,0 +1,21 @@
+module FSharpLint.Rules.DisallowShadowing
+
+open System
+
+open FSharpLint.Framework
+open FSharpLint.Framework.Suggestion
+open FSharp.Compiler.Syntax
+open FSharp.Compiler.Text
+open FSharp.Compiler.CodeAnalysis
+open FSharpLint.Framework.Ast
+open FSharpLint.Framework.Rules
+
+let runner (args: AstNodeRuleParams) =
+    
+    failwith "Not yet implemented"
+
+let rule =
+    { Name = "DisallowShadowing"
+      Identifier = Identifiers.DisallowShadowing
+      RuleConfig = { AstNodeRuleConfig.Runner = runner; Cleanup = ignore } }
+    |> AstNodeRule

src/FSharpLint.Core/Rules/Identifiers.fs

@@ -95,3 +95,4 @@ let InterpolatedStringWithNoSubstitution = identifier 87
 let IndexerAccessorStyleConsistency = identifier 88
 let FavourSingleton = identifier 89
 let NoAsyncRunSynchronouslyInLibrary = identifier 90
+let DisallowShadowing = identifier 91

tests/FSharpLint.Core.Tests/FSharpLint.Core.Tests.fsproj

@@ -50,6 +50,7 @@
     <Compile Include="Rules\Conventions\EnsureTailCallDiagnosticsInRecursiveFunctions.fs" />
     <Compile Include="Rules\Conventions\IndexerAccessorStyleConsistency.fs" />
     <Compile Include="Rules\Conventions\FavourSingleton.fs" />
+    <Compile Include="Rules\Conventions\DisallowShadowing.fs" />
     <Compile Include="Rules\Conventions\Naming\NamingHelpers.fs" />
     <Compile Include="Rules\Conventions\Naming\InterfaceNames.fs" />
     <Compile Include="Rules\Conventions\Naming\ExceptionNames.fs" />

tests/FSharpLint.Core.Tests/Rules/Conventions/DisallowShadowing.fs

@@ -0,0 +1,139 @@
+module FSharpLint.Core.Tests.Rules.Conventions.DisallowShadowing
+
+open NUnit.Framework
+
+open FSharpLint.Rules
+open FSharpLint.Core.Tests
+
+[<TestFixture>]
+type TestConventionsDisallowShadowing() =
+    inherit TestAstNodeRuleBase.TestAstNodeRuleBase(DisallowShadowing.rule)
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable``() =
+        this.Parse """
+let foo = 0
+
+module Foo =
+    let foo = 1"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable, inside function``() =
+        this.Parse """
+let bar () =
+    let foo = 0
+    let foo = 1
+    foo"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (function argument)``() =
+        this.Parse """
+let foo = 0
+let bar foo = foo + 1"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (function argument, inside function)``() =
+        this.Parse """
+let baz () =
+    let foo = 0
+    let bar foo = foo + 1
+    ()"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (function argument, nested)``() =
+        this.Parse """
+let baz foo =
+    let bar foo = foo + 1
+    ()"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (function argument, tuple)``() =
+        this.Parse """
+let foo = 0
+let bar (foo, baz) = foo + baz"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (lambda function argument)``() =
+        this.Parse """
+let foo = 0
+(fun foo -> foo + 1) 0 |> ignore"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable inside lambda function``() =
+        this.Parse """
+(fun foo ->
+    let foo = foo + 1
+    foo) 0 |> ignore"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (match pattern)``() =
+        this.Parse """
+let foo = 0
+match 1 with
+| foo -> foo"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable (as match pattern)``() =
+        this.Parse """
+let foo = 0
+match (1, 2) with
+| (x, y) as foo -> foo"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable inside match pattern``() =
+        this.Parse """
+match 1 with
+| foo -> 
+    let foo = foo + 1
+    foo"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable inside type definition``() =
+        this.Parse """
+type Foo(foo) =
+    let foo = foo + 1
+    
+    member this.Bar = foo"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should produce error for shadowed variable inside member definition``() =
+        this.Parse """
+type Foo() =
+    member this.Bar(foo) = 
+        let foo = foo + 1
+        foo"""
+
+        Assert.IsTrue this.ErrorsExist
+
+    [<Test>]
+    member this.``Should not produce error when variable with same name exists in another module``() =
+        this.Parse """
+module Foo =
+    let foo = 0
+let foo = 1"""
+
+        Assert.IsTrue this.NoErrorsExist