diff --git a/src/Review/Rule3.elm b/src/Review/Rule3.elm deleted file mode 100644 index 8b6b630e..00000000 --- a/src/Review/Rule3.elm +++ /dev/null @@ -1,710 +0,0 @@ -module Review.Rule3 exposing - ( ModuleRuleSchema - , ProjectRuleSchema - , fromModuleRuleSchema - , fromProjectRuleSchema - , newModuleRuleSchema - , newProjectRuleSchema - , review - , withContextFromImportedModules - , withDeclarationEnterVisitor - , withDeclarationExitVisitor - , withDeclarationListVisitor - , withDependenciesModuleVisitor - , withDependenciesProjectVisitor - , withElmJsonModuleVisitor - , withElmJsonProjectVisitor - , withExpressionEnterVisitor - , withExpressionExitVisitor - , withExpressionVisitor - , withFinalModuleEvaluation - , withFinalProjectEvaluation - , withImportVisitor - , withModuleContext - , withModuleDefinitionVisitor - , withModuleVisitor - , withReadmeModuleVisitor - , withReadmeProjectVisitor - , withSimpleCommentsVisitor - , withSimpleDeclarationVisitor - , withSimpleExpressionVisitor - , withSimpleImportVisitor - , withSimpleModuleDefinitionVisitor - ) - -import Dict exposing (Dict) -import Elm.Project -import Elm.Syntax.Declaration exposing (Declaration) -import Elm.Syntax.Expression exposing (Expression) -import Elm.Syntax.Import exposing (Import) -import Elm.Syntax.Module exposing (Module) -import Elm.Syntax.ModuleName exposing (ModuleName) -import Elm.Syntax.Node as Node exposing (Node) -import Elm.Syntax.Range as Range -import Review.Context as Context exposing (Context) -import Review.Error exposing (ReviewError) -import Review.Exceptions as Exceptions -import Review.Metadata as Metadata -import Review.Project exposing (Project) -import Review.Project.Dependency -import Review.Project.Internal -import Review.Rule - exposing - ( Direction(..) - , ElmJsonKey(..) - , Error(..) - , Forbidden - , ModuleKey(..) - , ReadmeKey(..) - , Required - , Rule(..) - , TraversalType(..) - , duplicateModuleNames - , errorToReviewError - , parsingError - , removeErrorPhantomType - ) -import Review.Visitor exposing (Folder, Visitor) -import Vendor.Graph as Graph - - -type ProjectRuleSchema schemaState projectContext moduleContext - = ProjectRuleSchema - { name : String - , initialProjectContext : projectContext - , elmJsonVisitors : List (Maybe { elmJsonKey : ElmJsonKey, project : Elm.Project.Project } -> projectContext -> ( List (Error {}), projectContext )) - , readmeVisitors : List (Maybe { readmeKey : ReadmeKey, content : String } -> projectContext -> ( List (Error {}), projectContext )) - , dependenciesVisitors : List (Dict String Review.Project.Dependency.Dependency -> projectContext -> ( List (Error {}), projectContext )) - , moduleVisitors : List (ModuleRuleSchema {} moduleContext -> ModuleRuleSchema { hasAtLeastOneVisitor : () } moduleContext) - , moduleContextCreator : Maybe (Context projectContext moduleContext) - , folder : Maybe (Folder projectContext moduleContext) - - -- TODO Jeroen Only allow to set it if there is a folder, but not several times - , traversalType : TraversalType - - -- TODO Jeroen Only allow to set it if there is a folder and module visitors? - , finalEvaluationFns : List (projectContext -> List (Error {})) - } - - -newProjectRuleSchema : String -> projectContext -> ProjectRuleSchema { canAddModuleVisitor : (), withModuleContext : Forbidden } projectContext moduleContext -newProjectRuleSchema name initialProjectContext = - ProjectRuleSchema - { name = name - , initialProjectContext = initialProjectContext - , elmJsonVisitors = [] - , readmeVisitors = [] - , dependenciesVisitors = [] - , moduleVisitors = [] - , moduleContextCreator = Nothing - , folder = Nothing - , traversalType = AllModulesInParallel - , finalEvaluationFns = [] - } - - -type ModuleRuleSchema schemaState moduleContext - = ModuleRuleSchema - { name : String - , initialModuleContext : Maybe moduleContext - , moduleContextCreator : Context () moduleContext - , moduleDefinitionVisitors : List (Visitor Module moduleContext) - , commentsVisitors : List (List (Node String) -> moduleContext -> ( List (Error {}), moduleContext )) - , importVisitors : List (Visitor Import moduleContext) - , declarationListVisitors : List (List (Node Declaration) -> moduleContext -> ( List (Error {}), moduleContext )) - , declarationVisitorsOnEnter : List (Visitor Declaration moduleContext) - , declarationVisitorsOnExit : List (Visitor Declaration moduleContext) - , expressionVisitorsOnEnter : List (Visitor Expression moduleContext) - , expressionVisitorsOnExit : List (Visitor Expression moduleContext) - , finalEvaluationFns : List (moduleContext -> List (Error {})) - - -- Project visitors - , elmJsonVisitors : List (Maybe Elm.Project.Project -> moduleContext -> moduleContext) - , readmeVisitors : List (Maybe String -> moduleContext -> moduleContext) - , dependenciesVisitors : List (Dict String Review.Project.Dependency.Dependency -> moduleContext -> moduleContext) - } - - -withModuleVisitor : - (ModuleRuleSchema {} moduleContext -> ModuleRuleSchema { hasAtLeastOneVisitor : () } moduleContext) - -> ProjectRuleSchema { projectSchemaState | canAddModuleVisitor : () } projectContext moduleContext - -- TODO BREAKING Change: add hasAtLeastOneVisitor : () - -> ProjectRuleSchema { projectSchemaState | canAddModuleVisitor : (), withModuleContext : Required } projectContext moduleContext -withModuleVisitor visitor (ProjectRuleSchema schema) = - ProjectRuleSchema { schema | moduleVisitors = visitor :: schema.moduleVisitors } - - -newModuleRuleSchema : String -> moduleContext -> ModuleRuleSchema { canCollectProjectData : () } moduleContext -newModuleRuleSchema name initialModuleContext = - ModuleRuleSchema - { name = name - , initialModuleContext = Just initialModuleContext - , moduleContextCreator = Context.init (always initialModuleContext) - , moduleDefinitionVisitors = [] - , commentsVisitors = [] - , importVisitors = [] - , declarationListVisitors = [] - , declarationVisitorsOnEnter = [] - , declarationVisitorsOnExit = [] - , expressionVisitorsOnEnter = [] - , expressionVisitorsOnExit = [] - , finalEvaluationFns = [] - , elmJsonVisitors = [] - , readmeVisitors = [] - , dependenciesVisitors = [] - } - - -withModuleContext : - { fromProjectToModule : ModuleKey -> Node ModuleName -> projectContext -> moduleContext - , fromModuleToProject : ModuleKey -> Node ModuleName -> moduleContext -> projectContext - , foldProjectContexts : projectContext -> projectContext -> projectContext - } - -> ProjectRuleSchema { schemaState | canAddModuleVisitor : (), withModuleContext : Required } projectContext moduleContext - -> ProjectRuleSchema { schemaState | hasAtLeastOneVisitor : (), withModuleContext : Forbidden } projectContext moduleContext -withModuleContext functions (ProjectRuleSchema schema) = - let - moduleContextCreator : Context projectContext moduleContext - moduleContextCreator = - Context.init - (\moduleKey metadata projectContext -> - functions.fromProjectToModule - moduleKey - (Metadata.moduleNameNode metadata) - projectContext - ) - |> Context.withModuleKey - |> Context.withMetadata - in - ProjectRuleSchema - { schema - | moduleContextCreator = Just moduleContextCreator - , folder = - Just - { fromModuleToProject = - Context.init (\moduleKey metadata moduleContext -> functions.fromModuleToProject moduleKey (Metadata.moduleNameNode metadata) moduleContext) - |> Context.withModuleKey - |> Context.withMetadata - , foldProjectContexts = functions.foldProjectContexts - } - } - - -withContextFromImportedModules : ProjectRuleSchema schemaState projectContext moduleContext -> ProjectRuleSchema schemaState projectContext moduleContext -withContextFromImportedModules (ProjectRuleSchema schema) = - ProjectRuleSchema { schema | traversalType = ImportedModulesFirst } - - -{-| Create a [`Rule`](#Rule) from a configured [`ModuleRuleSchema`](#ModuleRuleSchema). --} -fromModuleRuleSchema : ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -> Rule -fromModuleRuleSchema ((ModuleRuleSchema schema) as moduleVisitor) = - -- TODO BREAKING CHANGE Add canCollectData as a pre-requisite to using fromModuleRuleSchema - ProjectRuleSchema - { name = schema.name - , initialProjectContext = getInitialContextFromModuleRule moduleVisitor - , elmJsonVisitors = compactProjectDataVisitors (Maybe.map .project) schema.elmJsonVisitors - , readmeVisitors = compactProjectDataVisitors (Maybe.map .content) schema.readmeVisitors - , dependenciesVisitors = compactProjectDataVisitors identity schema.dependenciesVisitors - , moduleVisitors = [ removeExtensibleRecordTypeVariable (always moduleVisitor) ] - , moduleContextCreator = Just (Context.init identity) - , folder = Nothing - , traversalType = AllModulesInParallel - , finalEvaluationFns = [] - } - |> fromProjectRuleSchema - - -getInitialContextFromModuleRule : ModuleRuleSchema schemaState moduleContext -> moduleContext -getInitialContextFromModuleRule ((ModuleRuleSchema schema) as moduleVisitor) = - case schema.initialModuleContext of - Just initialModuleContext -> - initialModuleContext - - Nothing -> - -- Hack: For module rules, we know we will always have a module context - -- I am adding a `|>` to prevent TCO from kicking in, so that people get a runtime crash and an report it - -- rather than a mysterious. - -- Note: People can call this rule on a module rule built in `withModuleVisitor`, which we will prevent - -- in the next major version - moduleVisitor |> getInitialContextFromModuleRule - - -compactProjectDataVisitors : (rawData -> data) -> List (data -> moduleContext -> moduleContext) -> List (rawData -> moduleContext -> ( List nothing, moduleContext )) -compactProjectDataVisitors getData visitors = - if List.isEmpty visitors then - [] - - else - [ \rawData moduleContext -> - let - data : data - data = - getData rawData - in - ( [] - , List.foldl - (\visitor moduleContext_ -> visitor data moduleContext_) - moduleContext - (List.reverse visitors) - ) - ] - - -{-| This function that is supplied by the user will be stored in the `ProjectRuleSchema`, -but it contains an extensible record. This means that `ProjectRuleSchema` will -need an additional type variable for no useful value. Because we have full control -over the `ModuleRuleSchema` in this module, we can change the phantom type to be -whatever we want it to be, and we'll change it something that makes sense but -without the extensible record type variable. --} -removeExtensibleRecordTypeVariable : - (ModuleRuleSchema {} moduleContext -> ModuleRuleSchema { a | hasAtLeastOneVisitor : () } moduleContext) - -> (ModuleRuleSchema {} moduleContext -> ModuleRuleSchema { hasAtLeastOneVisitor : () } moduleContext) -removeExtensibleRecordTypeVariable function = - function >> (\(ModuleRuleSchema param) -> ModuleRuleSchema param) - - -{-| Add a visitor to the [`ModuleRuleSchema`](#ModuleRuleSchema) which will visit the project's -[`elm.json`](https://package.elm-lang.org/packages/elm/project-metadata-utils/latest/Elm-Project) file. - -The following example forbids exposing a module in an "Internal" directory in your `elm.json` file. - - import Elm.Module - import Elm.Project - import Elm.Syntax.Module as Module exposing (Module) - import Elm.Syntax.Node as Node exposing (Node) - import Review.Rule as Rule exposing (Error, Rule) - - type alias Context = - Maybe Elm.Project.Project - - rule : Rule - rule = - Rule.newModuleRuleSchema "DoNoExposeInternalModules" Nothing - |> Rule.withElmJsonModuleVisitor elmJsonVisitor - |> Rule.withModuleDefinitionVisitor moduleDefinitionVisitor - |> Rule.fromModuleRuleSchema - - elmJsonVisitor : Maybe Elm.Project.Project -> Context -> Context - elmJsonVisitor elmJson context = - elmJson - - moduleDefinitionVisitor : Node Module -> Context -> ( List (Error {}), Context ) - moduleDefinitionVisitor node context = - let - moduleName : List String - moduleName = - Node.value node |> Module.moduleName - in - if List.member "Internal" moduleName then - case context of - Just (Elm.Project.Package { exposed }) -> - let - exposedModules : List String - exposedModules = - case exposed of - Elm.Project.ExposedList names -> - names - |> List.map Elm.Module.toString - - Elm.Project.ExposedDict fakeDict -> - fakeDict - |> List.concatMap Tuple.second - |> List.map Elm.Module.toString - in - if List.member (String.join "." moduleName) exposedModules then - ( [ Rule.error "Do not expose modules in `Internal` as part of the public API" (Node.range node) ], context ) - - else - ( [], context ) - - _ -> - ( [], context ) - - else - ( [], context ) - --} -withElmJsonModuleVisitor : - (Maybe Elm.Project.Project -> moduleContext -> moduleContext) - -> ModuleRuleSchema { schemaState | canCollectProjectData : () } moduleContext - -> ModuleRuleSchema { schemaState | canCollectProjectData : () } moduleContext -withElmJsonModuleVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | elmJsonVisitors = visitor :: schema.elmJsonVisitors } - - -{-| Add a visitor to the [`ModuleRuleSchema`](#ModuleRuleSchema) which will visit -the project's `README.md` file. --} -withReadmeModuleVisitor : - (Maybe String -> moduleContext -> moduleContext) - -> ModuleRuleSchema { schemaState | canCollectProjectData : () } moduleContext - -> ModuleRuleSchema { schemaState | canCollectProjectData : () } moduleContext -withReadmeModuleVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | readmeVisitors = visitor :: schema.readmeVisitors } - - -{-| Add a visitor to the [`ProjectRuleSchema`](#ProjectRuleSchema) which will visit the project's -[dependencies](./Review-Project-Dependency). - -You can use this look at the modules contained in dependencies, which can make the rule very precise when it targets -specific functions. - --} -withDependenciesModuleVisitor : - (Dict String Review.Project.Dependency.Dependency -> moduleContext -> moduleContext) - -> ModuleRuleSchema { schemaState | canCollectProjectData : () } moduleContext - -> ModuleRuleSchema { schemaState | canCollectProjectData : () } moduleContext -withDependenciesModuleVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | dependenciesVisitors = visitor :: schema.dependenciesVisitors } - - -withElmJsonProjectVisitor : - (Maybe { elmJsonKey : ElmJsonKey, project : Elm.Project.Project } -> projectContext -> ( List (Error {}), projectContext )) - -> ProjectRuleSchema schemaState projectContext moduleContext - -> ProjectRuleSchema { schemaState | hasAtLeastOneVisitor : () } projectContext moduleContext -withElmJsonProjectVisitor visitor (ProjectRuleSchema projectRuleSchema) = - -- TODO BREAKING CHANGE, make elm.json mandatory - -- TODO BREAKING CHANGE, Rename to withElmJsonVisitor - ProjectRuleSchema { projectRuleSchema | elmJsonVisitors = visitor :: projectRuleSchema.elmJsonVisitors } - - -withReadmeProjectVisitor : - (Maybe { readmeKey : ReadmeKey, content : String } -> projectContext -> ( List (Error {}), projectContext )) - -> ProjectRuleSchema schemaState projectContext moduleContext - -> ProjectRuleSchema { schemaState | hasAtLeastOneVisitor : () } projectContext moduleContext -withReadmeProjectVisitor visitor (ProjectRuleSchema projectRuleSchema) = - -- TODO BREAKING CHANGE, Rename to withReadmeVisitor - ProjectRuleSchema { projectRuleSchema | readmeVisitors = visitor :: projectRuleSchema.readmeVisitors } - - -withDependenciesProjectVisitor : - (Dict String Review.Project.Dependency.Dependency -> projectContext -> ( List (Error {}), projectContext )) - -> ProjectRuleSchema schemaState projectContext moduleContext - -> ProjectRuleSchema { schemaState | hasAtLeastOneVisitor : () } projectContext moduleContext -withDependenciesProjectVisitor visitor (ProjectRuleSchema projectRuleSchema) = - -- TODO BREAKING CHANGE, Rename to withDependenciesVisitor - ProjectRuleSchema { projectRuleSchema | dependenciesVisitors = visitor :: projectRuleSchema.dependenciesVisitors } - - -withFinalProjectEvaluation : - (projectContext -> List (Error { useErrorForModule : () })) - -> ProjectRuleSchema schemaState projectContext moduleContext - -> ProjectRuleSchema { schemaState | hasAtLeastOneVisitor : () } projectContext moduleContext -withFinalProjectEvaluation visitor (ProjectRuleSchema projectRuleSchema) = - let - removeErrorPhantomTypeFromEvaluation : (projectContext -> List (Error b)) -> (projectContext -> List (Error {})) - removeErrorPhantomTypeFromEvaluation function projectContext = - function projectContext - |> List.map removeErrorPhantomType - in - ProjectRuleSchema { projectRuleSchema | finalEvaluationFns = removeErrorPhantomTypeFromEvaluation visitor :: projectRuleSchema.finalEvaluationFns } - - -fromProjectRuleSchema : ProjectRuleSchema { schemaState | hasAtLeastOneVisitor : () } projectContext moduleContext -> Rule -fromProjectRuleSchema ((ProjectRuleSchema schema) as projectRuleSchema) = - Rule - { exceptions = Exceptions.init - , ruleImplementation = Review.Visitor.run schema.name (fromProjectRuleSchemaToRunnableProjectVisitor projectRuleSchema) Nothing - } - - -fromProjectRuleSchemaToRunnableProjectVisitor : ProjectRuleSchema schemaState projectContext moduleContext -> Review.Visitor.RunnableProjectVisitor projectContext moduleContext -fromProjectRuleSchemaToRunnableProjectVisitor (ProjectRuleSchema schema) = - { initialProjectContext = schema.initialProjectContext - , elmJsonVisitors = List.reverse schema.elmJsonVisitors - , readmeVisitors = List.reverse schema.readmeVisitors - , dependenciesVisitors = List.reverse schema.dependenciesVisitors - , moduleVisitor = mergeModuleVisitors schema.initialProjectContext schema.moduleContextCreator schema.moduleVisitors - , traversalAndFolder = - case ( schema.traversalType, schema.folder ) of - ( AllModulesInParallel, _ ) -> - Review.Visitor.TraverseAllModulesInParallel schema.folder - - ( ImportedModulesFirst, Just folder ) -> - Review.Visitor.TraverseImportedModulesFirst folder - - ( ImportedModulesFirst, Nothing ) -> - Review.Visitor.TraverseAllModulesInParallel Nothing - , finalEvaluationFns = List.reverse schema.finalEvaluationFns - } - - -mergeModuleVisitors : - projectContext - -> Maybe (Context projectContext moduleContext) - -> List (ModuleRuleSchema schemaState1 moduleContext -> ModuleRuleSchema schemaState2 moduleContext) - -> Maybe ( Review.Visitor.RunnableModuleVisitor moduleContext, Context projectContext moduleContext ) -mergeModuleVisitors initialProjectContext maybeModuleContextCreator visitors = - case ( maybeModuleContextCreator, List.isEmpty visitors ) of - ( Nothing, _ ) -> - Nothing - - ( _, True ) -> - Nothing - - ( Just moduleContextCreator, False ) -> - let - dummyAvailableData : Context.AvailableData - dummyAvailableData = - { metadata = Metadata.createMetadata { moduleNameNode = Node.Node Range.emptyRange [] } - , moduleKey = ModuleKey "dummy" - } - - initialModuleContext : moduleContext - initialModuleContext = - Context.apply dummyAvailableData moduleContextCreator initialProjectContext - - emptyModuleVisitor : ModuleRuleSchema schemaState moduleContext - emptyModuleVisitor = - ModuleRuleSchema - { name = "" - , initialModuleContext = Just initialModuleContext - , moduleContextCreator = Context.init (always initialModuleContext) - , moduleDefinitionVisitors = [] - , commentsVisitors = [] - , importVisitors = [] - , declarationListVisitors = [] - , declarationVisitorsOnEnter = [] - , declarationVisitorsOnExit = [] - , expressionVisitorsOnEnter = [] - , expressionVisitorsOnExit = [] - , finalEvaluationFns = [] - , elmJsonVisitors = [] - , readmeVisitors = [] - , dependenciesVisitors = [] - } - in - Just - ( List.foldl - (\addVisitors (ModuleRuleSchema moduleVisitorSchema) -> - addVisitors (ModuleRuleSchema moduleVisitorSchema) - ) - emptyModuleVisitor - visitors - |> fromModuleRuleSchemaToRunnableModuleVisitor - , moduleContextCreator - ) - - -fromModuleRuleSchemaToRunnableModuleVisitor : ModuleRuleSchema schemaState moduleContext -> Review.Visitor.RunnableModuleVisitor moduleContext -fromModuleRuleSchemaToRunnableModuleVisitor (ModuleRuleSchema schema) = - { moduleDefinitionVisitors = List.reverse schema.moduleDefinitionVisitors - , commentsVisitors = List.reverse schema.commentsVisitors - , importVisitors = List.reverse schema.importVisitors - , declarationListVisitors = List.reverse schema.declarationListVisitors - , declarationVisitorsOnEnter = List.reverse schema.declarationVisitorsOnEnter - , declarationVisitorsOnExit = schema.declarationVisitorsOnExit - , expressionVisitorsOnEnter = List.reverse schema.expressionVisitorsOnEnter - , expressionVisitorsOnExit = schema.expressionVisitorsOnExit - , finalEvaluationFns = List.reverse schema.finalEvaluationFns - } - - -withSimpleModuleDefinitionVisitor : (Node Module -> List (Error {})) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withSimpleModuleDefinitionVisitor visitor schema = - withModuleDefinitionVisitor (\node moduleContext -> ( visitor node, moduleContext )) schema - - -withModuleDefinitionVisitor : (Node Module -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withModuleDefinitionVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | moduleDefinitionVisitors = visitor :: schema.moduleDefinitionVisitors } - - -withSimpleCommentsVisitor : (List (Node String) -> List (Error {})) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withSimpleCommentsVisitor visitor schema = - withCommentsVisitor (\node moduleContext -> ( visitor node, moduleContext )) schema - - -withCommentsVisitor : (List (Node String) -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withCommentsVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | commentsVisitors = visitor :: schema.commentsVisitors } - - -withSimpleImportVisitor : (Node Import -> List (Error {})) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withSimpleImportVisitor visitor schema = - withImportVisitor (\node moduleContext -> ( visitor node, moduleContext )) schema - - -withImportVisitor : (Node Import -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withImportVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | importVisitors = visitor :: schema.importVisitors } - - -withSimpleDeclarationVisitor : (Node Declaration -> List (Error {})) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withSimpleDeclarationVisitor visitor schema = - withDeclarationEnterVisitor - (\node moduleContext -> ( visitor node, moduleContext )) - schema - - -withDeclarationEnterVisitor : (Node Declaration -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withDeclarationEnterVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | declarationVisitorsOnEnter = visitor :: schema.declarationVisitorsOnEnter } - - -withDeclarationExitVisitor : (Node Declaration -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withDeclarationExitVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | declarationVisitorsOnExit = visitor :: schema.declarationVisitorsOnExit } - - -withDeclarationListVisitor : (List (Node Declaration) -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withDeclarationListVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | declarationListVisitors = visitor :: schema.declarationListVisitors } - - -withSimpleExpressionVisitor : (Node Expression -> List (Error {})) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withSimpleExpressionVisitor visitor schema = - withExpressionEnterVisitor - (\node moduleContext -> ( visitor node, moduleContext )) - schema - - -withExpressionVisitor : (Node Expression -> Direction -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withExpressionVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema - { schema - | expressionVisitorsOnEnter = (\node ctx -> visitor node OnEnter ctx) :: schema.expressionVisitorsOnEnter - , expressionVisitorsOnExit = (\node ctx -> visitor node OnExit ctx) :: schema.expressionVisitorsOnExit - } - - -withExpressionEnterVisitor : (Node Expression -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withExpressionEnterVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | expressionVisitorsOnEnter = visitor :: schema.expressionVisitorsOnEnter } - - -withExpressionExitVisitor : (Node Expression -> moduleContext -> ( List (Error {}), moduleContext )) -> ModuleRuleSchema schemaState moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withExpressionExitVisitor visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | expressionVisitorsOnExit = visitor :: schema.expressionVisitorsOnExit } - - -withFinalModuleEvaluation : (moduleContext -> List (Error {})) -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -> ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } moduleContext -withFinalModuleEvaluation visitor (ModuleRuleSchema schema) = - ModuleRuleSchema { schema | finalEvaluationFns = visitor :: schema.finalEvaluationFns } - - - --- REVIEWING - - -{-| Review a project and gives back the errors raised by the given rules. - -Note that you won't need to use this function when writing a rule. You should -only need it if you try to make `elm-review` run in a new environment. - - import Review.Project as Project exposing (Project, ProjectModule) - import Review.Rule as Rule exposing (Rule) - - config : List Rule - config = - [ Some.Rule.rule - , Some.Other.Rule.rule - ] - - project : Project - project = - Project.new - |> Project.addModule { path = "src/A.elm", source = "module A exposing (a)\na = 1" } - |> Project.addModule { path = "src/B.elm", source = "module B exposing (b)\nb = 1" } - - doReview = - let - ( errors, rulesWithCachedValues ) = - Rule.review rules project - in - doSomethingWithTheseValues - -The resulting `List Rule` is the same list of rules given as input, but with an -updated internal cache to make it faster to re-run the rules on the same project. -If you plan on re-reviewing with the same rules and project, for instance to -review the project after a file has changed, you may want to store the rules in -your `Model`. - -The rules are functions, so doing so will make your model unable to be -exported/imported with `elm/browser`'s debugger, and may cause a crash if you try -to compare them or the model that holds them. - --} -review : List Rule -> Project -> ( List ReviewError, List Rule ) -review rules project = - case Review.Project.modulesThatFailedToParse project of - [] -> - case Review.Project.modules project |> duplicateModuleNames Dict.empty of - Just duplicate -> - let - paths : String - paths = - duplicate.paths - |> List.sort - |> List.map (\s -> "\n - " ++ s) - |> String.join "" - - moduleNames : String - moduleNames = - String.join "." duplicate.moduleName - in - ( [ Review.Error.ReviewError - { filePath = "GLOBAL ERROR" - , ruleName = "Incorrect project" - , message = "Found several modules named `" ++ moduleNames ++ "`" - , details = - [ "I found several modules with the name `" ++ moduleNames ++ "`. Depending on how I choose to resolve this, I might give you different reports. Since this is a compiler error anyway, I require this problem to be solved. Please fix this then try running `elm-review` again." - , "Here are the paths to some of the files that share a module name:" ++ paths - , "It is possible that you requested me to look at several projects, and that modules from each project share the same name. I don't recommend reviewing several projects at the same time, as I can only handle one `elm.json`. I instead suggest running `elm-review` twice, once for each project." - ] - , range = { start = { row = 0, column = 0 }, end = { row = 0, column = 0 } } - , fixes = Nothing - , target = Review.Error.Global - } - ] - , rules - ) - - Nothing -> - let - sortedModules : Result (Graph.Edge ()) (List (Graph.NodeContext ModuleName ())) - sortedModules = - project - |> Review.Project.Internal.moduleGraph - |> Graph.checkAcyclic - |> Result.map Graph.topologicalSort - in - case sortedModules of - Err _ -> - ( [ Review.Error.ReviewError - { filePath = "GLOBAL ERROR" - , ruleName = "Incorrect project" - , message = "Import cycle discovered" - , details = - [ "I detected an import cycle in your project. This prevents me from working correctly, and results in a error for the Elm compiler anyway. Please resolve it using the compiler's suggestions, then try running `elm-review` again." - ] - , range = { start = { row = 0, column = 0 }, end = { row = 0, column = 0 } } - , fixes = Nothing - , target = Review.Error.Global - } - ] - , rules - ) - - Ok nodeContexts -> - runRules rules project nodeContexts - |> Tuple.mapFirst (List.map errorToReviewError) - - modulesThatFailedToParse -> - ( List.map parsingError modulesThatFailedToParse, rules ) - - -runRules : List Rule -> Project -> List (Graph.NodeContext ModuleName ()) -> ( List (Error {}), List Rule ) -runRules rules project nodeContexts = - List.foldl - (\(Rule { exceptions, ruleImplementation }) ( errors, previousRules ) -> - let - ( ruleErrors, ruleWithCache ) = - ruleImplementation exceptions project nodeContexts - in - ( List.concat [ List.map removeErrorPhantomType ruleErrors, errors ], ruleWithCache :: previousRules ) - ) - ( [], [] ) - rules diff --git a/tests/Documentation/ReadmeLinksPointToCurrentVersion.elm b/tests/Documentation/ReadmeLinksPointToCurrentVersion.elm index 7cc9a440..1e5fcad0 100644 --- a/tests/Documentation/ReadmeLinksPointToCurrentVersion.elm +++ b/tests/Documentation/ReadmeLinksPointToCurrentVersion.elm @@ -13,7 +13,6 @@ import Elm.Version import Regex exposing (Regex) import Review.Fix as Fix import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports links in the `README.md` that point to this project's package documentation on , diff --git a/tests/MiscRules/NoBooleanCase.elm b/tests/MiscRules/NoBooleanCase.elm index 0385a07b..afdb9496 100644 --- a/tests/MiscRules/NoBooleanCase.elm +++ b/tests/MiscRules/NoBooleanCase.elm @@ -5,7 +5,6 @@ import Elm.Syntax.Node as Node exposing (Node) import Elm.Syntax.Pattern as Pattern import Elm.Syntax.Range exposing (Range) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 rule : Rule diff --git a/tests/MiscRules/NoUnusedTypeConstructors.elm b/tests/MiscRules/NoUnusedTypeConstructors.elm index 5abe5ed3..eec5f059 100644 --- a/tests/MiscRules/NoUnusedTypeConstructors.elm +++ b/tests/MiscRules/NoUnusedTypeConstructors.elm @@ -16,7 +16,6 @@ import Elm.Syntax.Expression exposing (Expression(..)) import Elm.Syntax.Module as Module exposing (Module(..)) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 import Set exposing (Set) diff --git a/tests/MiscRules/ReadmeStartsWithProjectTitle.elm b/tests/MiscRules/ReadmeStartsWithProjectTitle.elm index 05a112b2..6594b723 100644 --- a/tests/MiscRules/ReadmeStartsWithProjectTitle.elm +++ b/tests/MiscRules/ReadmeStartsWithProjectTitle.elm @@ -4,7 +4,6 @@ import Elm.Package import Elm.Project import Elm.Syntax.Range exposing (Range) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 rule : Rule diff --git a/tests/NoBooleanCaseOf.elm b/tests/NoBooleanCaseOf.elm index befea1a2..225c5741 100644 --- a/tests/NoBooleanCaseOf.elm +++ b/tests/NoBooleanCaseOf.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Node as Node exposing (Node) import Elm.Syntax.Pattern as Pattern exposing (Pattern) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports when pattern matching is used for a boolean value. diff --git a/tests/NoDebug/Log.elm b/tests/NoDebug/Log.elm index bb04effc..b4f57520 100644 --- a/tests/NoDebug/Log.elm +++ b/tests/NoDebug/Log.elm @@ -11,7 +11,6 @@ import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Import exposing (Import) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Forbid the use of [`Debug.log`](https://package.elm-lang.org/packages/elm/core/latest/Debug) before it goes into production or fails in the CI. diff --git a/tests/NoDebug/TodoOrToString.elm b/tests/NoDebug/TodoOrToString.elm index 4398306f..051e6835 100644 --- a/tests/NoDebug/TodoOrToString.elm +++ b/tests/NoDebug/TodoOrToString.elm @@ -11,7 +11,6 @@ import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Import exposing (Import) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Forbid the use of [`Debug.todo`] and [`Debug.toString`]. diff --git a/tests/NoExposingEverything.elm b/tests/NoExposingEverything.elm index 039c0e9f..0f5eb2ce 100644 --- a/tests/NoExposingEverything.elm +++ b/tests/NoExposingEverything.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Exposing as Exposing import Elm.Syntax.Module as Module exposing (Module) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Forbids exporting everything from a module. diff --git a/tests/NoExtraBooleanComparison.elm b/tests/NoExtraBooleanComparison.elm index 007f5e0c..fbbfc14e 100644 --- a/tests/NoExtraBooleanComparison.elm +++ b/tests/NoExtraBooleanComparison.elm @@ -12,7 +12,6 @@ module NoExtraBooleanComparison exposing (rule) import Elm.Syntax.Expression as Expression exposing (Expression(..)) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Forbid the use of boolean comparisons that can be simplified. @@ -63,8 +62,8 @@ You should not use this rule if you -} rule : Rule rule = - Rule3.newModuleRuleSchema "NoExtraBooleanComparison" () - |> Rule3.withSimpleExpressionVisitor expressionVisitor + Rule.newModuleRuleSchema "NoExtraBooleanComparison" () + |> Rule.withSimpleExpressionVisitor expressionVisitor |> Rule.fromModuleRuleSchema diff --git a/tests/NoFullyAppliedPrefixOperator.elm b/tests/NoFullyAppliedPrefixOperator.elm index 1d67541c..932a8fec 100644 --- a/tests/NoFullyAppliedPrefixOperator.elm +++ b/tests/NoFullyAppliedPrefixOperator.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Node as Node exposing (Node) import Elm.Syntax.Range exposing (Range) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports when an operator is used as a prefix operator and all the operands are already given. @@ -40,8 +39,8 @@ import Review.Rule3 as Rule3 -} rule : Rule rule = - Rule3.newModuleRuleSchema "NoFullyAppliedPrefixOperator" () - |> Rule3.withSimpleExpressionVisitor expressionVisitor + Rule.newModuleRuleSchema "NoFullyAppliedPrefixOperator" () + |> Rule.withSimpleExpressionVisitor expressionVisitor |> Rule.fromModuleRuleSchema diff --git a/tests/NoImportingEverything.elm b/tests/NoImportingEverything.elm index f61e8b4a..43ef1b7e 100644 --- a/tests/NoImportingEverything.elm +++ b/tests/NoImportingEverything.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Exposing as Exposing import Elm.Syntax.Import exposing (Import) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 import Set exposing (Set) diff --git a/tests/NoLeftPizza.elm b/tests/NoLeftPizza.elm index 5a263d98..ed7b9739 100644 --- a/tests/NoLeftPizza.elm +++ b/tests/NoLeftPizza.elm @@ -11,7 +11,6 @@ import Elm.Syntax.Node as Node exposing (Node) import NoLeftPizzaUtil import Review.Fix as Fix import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Specify how strict the rule should be. diff --git a/tests/NoListLiteralsConcat.elm b/tests/NoListLiteralsConcat.elm index 4b267799..f56080f4 100644 --- a/tests/NoListLiteralsConcat.elm +++ b/tests/NoListLiteralsConcat.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Node as Node exposing (Node) import Elm.Syntax.Range exposing (Range) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports when an operation on lists could be simplified to a single literal list. diff --git a/tests/NoMissingTypeAnnotation.elm b/tests/NoMissingTypeAnnotation.elm index 2e6f87d9..edaf7811 100644 --- a/tests/NoMissingTypeAnnotation.elm +++ b/tests/NoMissingTypeAnnotation.elm @@ -9,7 +9,6 @@ module NoMissingTypeAnnotation exposing (rule) import Elm.Syntax.Declaration as Declaration exposing (Declaration) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports top-level declarations that do not have a type annotation. diff --git a/tests/NoMissingTypeAnnotationInLetIn.elm b/tests/NoMissingTypeAnnotationInLetIn.elm index 1756c5b7..57abdb38 100644 --- a/tests/NoMissingTypeAnnotationInLetIn.elm +++ b/tests/NoMissingTypeAnnotationInLetIn.elm @@ -9,7 +9,6 @@ module NoMissingTypeAnnotationInLetIn exposing (rule) import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports `let in` declarations that do not have a type annotation. diff --git a/tests/NoRecursiveUpdate.elm b/tests/NoRecursiveUpdate.elm index 27a79ddc..d17bb00b 100644 --- a/tests/NoRecursiveUpdate.elm +++ b/tests/NoRecursiveUpdate.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Declaration as Declaration exposing (Declaration) import Elm.Syntax.Expression as Expression exposing (Expression) import Elm.Syntax.Node as Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports when the `update` function calls itself. diff --git a/tests/NoUnused/CustomTypeConstructors.elm b/tests/NoUnused/CustomTypeConstructors.elm index 11c6873e..c4a81894 100644 --- a/tests/NoUnused/CustomTypeConstructors.elm +++ b/tests/NoUnused/CustomTypeConstructors.elm @@ -21,7 +21,6 @@ import Elm.Syntax.Node as Node exposing (Node) import Elm.Syntax.Signature exposing (Signature) import Elm.Syntax.TypeAnnotation as TypeAnnotation exposing (TypeAnnotation) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 import Scope import Set exposing (Set) diff --git a/tests/NoUnused/Parameters.elm b/tests/NoUnused/Parameters.elm index c7d93d01..a3fc5e80 100644 --- a/tests/NoUnused/Parameters.elm +++ b/tests/NoUnused/Parameters.elm @@ -19,7 +19,6 @@ import Elm.Writer as Writer import NoUnused.Patterns.NameVisitor as NameVisitor import Review.Fix as Fix import Review.Rule as Rule exposing (Rule) -import Review.Rule3 as Rule3 import Set exposing (Set) @@ -58,7 +57,7 @@ rule = |> Rule.withDeclarationExitVisitor declarationExitVisitor |> Rule.withExpressionEnterVisitor expressionEnterVisitor |> Rule.withExpressionExitVisitor expressionExitVisitor - |> NameVisitor.withValueVisitor_New valueVisitor + |> NameVisitor.withValueVisitor valueVisitor |> Rule.fromModuleRuleSchema diff --git a/tests/NoUnused/Patterns.elm b/tests/NoUnused/Patterns.elm index 07696fc1..bc6c24c4 100644 --- a/tests/NoUnused/Patterns.elm +++ b/tests/NoUnused/Patterns.elm @@ -18,7 +18,6 @@ import Elm.Writer as Writer import NoUnused.Patterns.NameVisitor as NameVisitor import Review.Fix as Fix import Review.Rule as Rule exposing (Rule) -import Review.Rule3 as Rule3 import Set exposing (Set) @@ -58,7 +57,7 @@ rule = Rule.newModuleRuleSchema "NoUnused.Patterns" initialContext |> Rule.withExpressionEnterVisitor expressionEnterVisitor |> Rule.withExpressionExitVisitor expressionExitVisitor - |> NameVisitor.withValueVisitor_New valueVisitor + |> NameVisitor.withValueVisitor valueVisitor |> Rule.fromModuleRuleSchema diff --git a/tests/NoUnused/Patterns/NameVisitor.elm b/tests/NoUnused/Patterns/NameVisitor.elm index c007a255..a1b0210a 100644 --- a/tests/NoUnused/Patterns/NameVisitor.elm +++ b/tests/NoUnused/Patterns/NameVisitor.elm @@ -1,7 +1,4 @@ -module NoUnused.Patterns.NameVisitor exposing - ( withValueVisitor - , withValueVisitor_New - ) +module NoUnused.Patterns.NameVisitor exposing (withValueVisitor) {-| Visit each name in the module. @@ -39,7 +36,6 @@ import Elm.Syntax.Signature exposing (Signature) import Elm.Syntax.Type as Type import Elm.Syntax.TypeAnnotation as TypeAnnotation exposing (TypeAnnotation) import Review.Rule as Rule exposing (Error) -import Review.Rule3 as Rule3 type Visitor context @@ -180,20 +176,6 @@ withValueAndTypeVisitors { valueVisitor, typeVisitor } rule = |> Rule.withExpressionEnterVisitor (expressionVisitor visitor) -withValueVisitor_New : - (Node ( ModuleName, String ) -> context -> ( List (Error {}), context )) - -> Rule.ModuleRuleSchema state context - -> Rule.ModuleRuleSchema { state | hasAtLeastOneVisitor : () } context -withValueVisitor_New valueVisitor rule = - let - visitor = - ValueVisitor valueVisitor - in - rule - |> Rule.withDeclarationListVisitor (declarationListVisitor visitor) - |> Rule.withExpressionEnterVisitor (expressionVisitor visitor) - - --- VISITORS diff --git a/tests/NoUnused/Variables.elm b/tests/NoUnused/Variables.elm index ba25f1f9..68ec6764 100644 --- a/tests/NoUnused/Variables.elm +++ b/tests/NoUnused/Variables.elm @@ -22,7 +22,6 @@ import Elm.Syntax.TypeAnnotation as TypeAnnotation exposing (TypeAnnotation) import NoUnused.NonemptyList as NonemptyList exposing (Nonempty) import Review.Fix as Fix exposing (Fix) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 import Set exposing (Set) diff --git a/tests/NoUselessSubscriptions.elm b/tests/NoUselessSubscriptions.elm index 268c2dc5..f1c772dd 100644 --- a/tests/NoUselessSubscriptions.elm +++ b/tests/NoUselessSubscriptions.elm @@ -10,7 +10,6 @@ import Elm.Syntax.Declaration as Declaration exposing (Declaration) import Elm.Syntax.Expression as Expression import Elm.Syntax.Node as Node exposing (Node(..)) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 {-| Reports `subscriptions` functions that never return a subscription. @@ -45,8 +44,8 @@ that turn out to be unnecessary later. -} rule : Rule rule = - Rule3.newModuleRuleSchema "NoUselessSubscriptions" () - |> Rule3.withSimpleDeclarationVisitor declarationVisitor + Rule.newModuleRuleSchema "NoUselessSubscriptions" () + |> Rule.withSimpleDeclarationVisitor declarationVisitor |> Rule.fromModuleRuleSchema diff --git a/tests/Review/Rule/VisitorsOrderTest.elm b/tests/Review/Rule/VisitorsOrderTest.elm index 38982dc2..8a4cbe64 100644 --- a/tests/Review/Rule/VisitorsOrderTest.elm +++ b/tests/Review/Rule/VisitorsOrderTest.elm @@ -4,7 +4,6 @@ import Elm.Syntax.Declaration exposing (Declaration) import Elm.Syntax.Expression exposing (Expression) import Elm.Syntax.Node exposing (Node) import Review.Rule as Rule exposing (Error, Rule) -import Review.Rule3 as Rule3 import Review.Test import Test exposing (Test, test) diff --git a/tests/Scope.elm b/tests/Scope.elm index 1fc2653c..acb65b0b 100644 --- a/tests/Scope.elm +++ b/tests/Scope.elm @@ -76,7 +76,6 @@ import Elm.Syntax.TypeAnnotation as TypeAnnotation exposing (TypeAnnotation) import Elm.Type import Review.Project.Dependency as Dependency exposing (Dependency) import Review.Rule as Rule -import Review.Rule3 as Rule3 import Set exposing (Set) @@ -351,13 +350,13 @@ addProjectVisitors schema = addProjectVisitors_New : - Rule3.ProjectRuleSchema { schemaState | canAddModuleVisitor : () } { projectContext | scope : ProjectContext } { moduleContext | scope : ModuleContext } - -> Rule3.ProjectRuleSchema { schemaState | canAddModuleVisitor : (), hasAtLeastOneVisitor : (), withModuleContext : Rule.Required } { projectContext | scope : ProjectContext } { moduleContext | scope : ModuleContext } + Rule.ProjectRuleSchema { schemaState | canAddModuleVisitor : () } { projectContext | scope : ProjectContext } { moduleContext | scope : ModuleContext } + -> Rule.ProjectRuleSchema { schemaState | canAddModuleVisitor : (), hasAtLeastOneVisitor : (), withModuleContext : Rule.Required } { projectContext | scope : ProjectContext } { moduleContext | scope : ModuleContext } addProjectVisitors_New schema = schema - |> Rule3.withContextFromImportedModules - |> Rule3.withDependenciesProjectVisitor (mapInnerProjectContext dependenciesProjectVisitor) - |> Rule3.withModuleVisitor internalAddModuleVisitors_New + |> Rule.withContextFromImportedModules + |> Rule.withDependenciesProjectVisitor (mapInnerProjectContext dependenciesProjectVisitor) + |> Rule.withModuleVisitor internalAddModuleVisitors {-| Adds the scope visitors to your module rule. @@ -457,63 +456,6 @@ internalAddModuleVisitors schema = ) -internalAddModuleVisitors_New : Rule3.ModuleRuleSchema schemaState { moduleContext | scope : ModuleContext } -> Rule3.ModuleRuleSchema { schemaState | hasAtLeastOneVisitor : () } { moduleContext | scope : ModuleContext } -internalAddModuleVisitors_New schema = - schema - |> Rule3.withModuleDefinitionVisitor - (mapInnerModuleContext moduleDefinitionVisitor |> pairWithNoErrors) - |> Rule3.withImportVisitor - (mapInnerModuleContext importVisitor |> pairWithNoErrors) - |> Rule3.withDeclarationListVisitor - (mapInnerModuleContext declarationListVisitor |> pairWithNoErrors) - |> Rule3.withDeclarationEnterVisitor - (\visitedElement outerContext -> - let - innerContext : InnerModuleContext - innerContext = - outerContext.scope - |> unboxModule - |> declarationEnterVisitor visitedElement - in - ( [], { outerContext | scope = ModuleContext innerContext } ) - ) - |> Rule3.withDeclarationExitVisitor - (\visitedElement outerContext -> - let - innerContext : InnerModuleContext - innerContext = - outerContext.scope - |> unboxModule - |> declarationExitVisitor visitedElement - in - ( [], { outerContext | scope = ModuleContext innerContext } ) - ) - |> Rule3.withExpressionEnterVisitor - (\visitedElement outerContext -> - let - innerContext : InnerModuleContext - innerContext = - outerContext.scope - |> unboxModule - |> popScopeEnter visitedElement - |> expressionEnterVisitor visitedElement - in - ( [], { outerContext | scope = ModuleContext innerContext } ) - ) - |> Rule3.withExpressionExitVisitor - (\visitedElement outerContext -> - let - innerContext : InnerModuleContext - innerContext = - outerContext.scope - |> unboxModule - |> popScopeExit visitedElement - |> expressionExitVisitor visitedElement - in - ( [], { outerContext | scope = ModuleContext innerContext } ) - ) - - mapInnerProjectContext : (visitedElement -> InnerProjectContext -> InnerProjectContext) -> visitedElement -> { projectContext | scope : ProjectContext } -> ( List nothing, { projectContext | scope : ProjectContext } ) mapInnerProjectContext visitor visitedElement outerContext = let