From ceff31d21671c243148efe4afc681b96a9e00aa3 Mon Sep 17 00:00:00 2001 From: Hackerpilot Date: Fri, 30 Oct 2015 13:33:54 -0700 Subject: [PATCH] Fix #132 --- README.md | 3 ++- src/analysis/config.d | 3 +++ src/analysis/helpers.d | 7 +++--- src/analysis/line_length.d | 47 ++++++++++++++++++++++++++++++++++++++ src/analysis/run.d | 22 +++++++++++------- 5 files changed, 70 insertions(+), 12 deletions(-) create mode 100644 src/analysis/line_length.d diff --git a/README.md b/README.md index 9c8e441..ef05da3 100644 --- a/README.md +++ b/README.md @@ -83,10 +83,11 @@ you do not want to use the one created by the "--defaultConfig" option. * Variables that could have been declared const or immutable (experimental) * Redundant parenthesis. * Unused labels. +* Lines longer than 120 characters. #### Wishlist -[See this list of open issues](https://github.com/Hackerpilot/Dscanner/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement) for the wishlist. +[See this list of open issues](https://github.com/Hackerpilot/Dscanner/issues?q=is%3Aopen+is%3Aissue+label%3Aenhancement) for the wishlist. ### Reports The "--report" option writes a JSON report on the static analysis checks diff --git a/src/analysis/config.d b/src/analysis/config.d index e326d03..48068f0 100644 --- a/src/analysis/config.d +++ b/src/analysis/config.d @@ -98,4 +98,7 @@ struct StaticAnalysisConfig @INI("Checks for labels with the same name as variables") bool label_var_same_name_check; + + @INI("Checks for lines longer than 120 characters") + bool long_line_check; } diff --git a/src/analysis/helpers.d b/src/analysis/helpers.d index 75626ba..c1060bc 100644 --- a/src/analysis/helpers.d +++ b/src/analysis/helpers.d @@ -53,16 +53,17 @@ S after(S)(S value, S separator) void assertAnalyzerWarnings(string code, const StaticAnalysisConfig config, string file=__FILE__, size_t line=__LINE__) { import analysis.run : ParseAllocator, parseModule; - import dparse.lexer : StringCache; + import dparse.lexer : StringCache, Token; StringCache cache = StringCache(StringCache.defaultBucketCount); ParseAllocator p = new ParseAllocator; - const(Module) m = parseModule(file, cast(ubyte[]) code, p, cache, false); + const(Token)[] tokens; + const(Module) m = parseModule(file, cast(ubyte[]) code, p, cache, false, tokens); auto moduleCache = ModuleCache(p); // Run the code and get any warnings - MessageSet rawWarnings = analyze("test", m, config, moduleCache); + MessageSet rawWarnings = analyze("test", m, config, moduleCache, tokens); string[] codeLines = code.split("\n"); // Get the warnings ordered by line diff --git a/src/analysis/line_length.d b/src/analysis/line_length.d new file mode 100644 index 0000000..a4b2637 --- /dev/null +++ b/src/analysis/line_length.d @@ -0,0 +1,47 @@ +// Copyright Brian Schott (Hackerpilot) 2015. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +module analysis.line_length; + +import dparse.lexer; +import dparse.ast; +import analysis.base : BaseAnalyzer; + +/** + * Checks for lines longer than 120 characters + */ +class LineLengthCheck : BaseAnalyzer +{ + /// + this(string fileName, const(Token)[] tokens) + { + super(fileName, null); + this.tokens = tokens; + } + + override void visit(const Module) + { + ulong lastErrorLine = ulong.max; + foreach (token; tokens) + { + if (token.column + token.text.length > MAX_LINE_LENGTH && token.line != lastErrorLine) + { + addErrorMessage(token.line, token.column, KEY, MESSAGE); + lastErrorLine = token.line; + } + } + } + + alias visit = BaseAnalyzer.visit; + +private: + + import std.conv : to; + + enum string KEY = "dscanner.style.long_line"; + enum string MESSAGE = "Line is longer than " ~ to!string(MAX_LINE_LENGTH) ~ " characters"; + enum MAX_LINE_LENGTH = 120; + const(Token)[] tokens; +} diff --git a/src/analysis/run.d b/src/analysis/run.d index 672ba3c..bc69b3a 100644 --- a/src/analysis/run.d +++ b/src/analysis/run.d @@ -51,6 +51,7 @@ import analysis.if_statements; import analysis.redundant_parens; import analysis.mismatched_args; import analysis.label_var_same_name_check; +import analysis.line_length; import dsymbol.string_interning : internString; import dsymbol.scope_; @@ -114,9 +115,10 @@ void generateReport(string[] fileNames, const StaticAnalysisConfig config, auto code = uninitializedArray!(ubyte[])(to!size_t(f.size)); f.rawRead(code); ParseAllocator p = new ParseAllocator; - const Module m = parseModule(fileName, code, p, cache, true, &lineOfCodeCount); + const(Token)[] tokens; + const Module m = parseModule(fileName, code, p, cache, true, tokens, &lineOfCodeCount); stats.visit(m); - MessageSet results = analyze(fileName, m, config, moduleCache, true); + MessageSet results = analyze(fileName, m, config, moduleCache, tokens, true); foreach (result; results[]) { writeJSON(result.key, result.fileName, result.line, result.column, result.message); @@ -154,12 +156,13 @@ bool analyze(string[] fileNames, const StaticAnalysisConfig config, ParseAllocator p = new ParseAllocator; uint errorCount = 0; uint warningCount = 0; - const Module m = parseModule(fileName, code, p, cache, false, null, + const(Token)[] tokens; + const Module m = parseModule(fileName, code, p, cache, false, tokens, null, &errorCount, &warningCount); assert(m); if (errorCount > 0 || (staticAnalyze && warningCount > 0)) hasErrors = true; - MessageSet results = analyze(fileName, m, config, moduleCache, staticAnalyze); + MessageSet results = analyze(fileName, m, config, moduleCache, tokens, staticAnalyze); if (results is null) continue; foreach (result; results[]) @@ -170,15 +173,15 @@ bool analyze(string[] fileNames, const StaticAnalysisConfig config, } const(Module) parseModule(string fileName, ubyte[] code, ParseAllocator p, - ref StringCache cache, bool report, ulong* linesOfCode = null, - uint* errorCount = null, uint* warningCount = null) + ref StringCache cache, bool report, ref const(Token)[] tokens, + ulong* linesOfCode = null, uint* errorCount = null, uint* warningCount = null) { import stats : isLineOfCode; LexerConfig config; config.fileName = fileName; config.stringBehavior = StringBehavior.source; - const(Token)[] tokens = getTokensForParser(code, config, &cache); + tokens = getTokensForParser(code, config, &cache); if (linesOfCode !is null) (*linesOfCode) += count!(a => isLineOfCode(a.type))(tokens); return dparse.parser.parseModule(tokens, fileName, p, @@ -186,7 +189,8 @@ const(Module) parseModule(string fileName, ubyte[] code, ParseAllocator p, } MessageSet analyze(string fileName, const Module m, - const StaticAnalysisConfig analysisConfig, ref ModuleCache moduleCache, bool staticAnalyze = true) + const StaticAnalysisConfig analysisConfig, ref ModuleCache moduleCache, + const(Token)[] tokens, bool staticAnalyze = true) { if (!staticAnalyze) return null; @@ -254,6 +258,8 @@ MessageSet analyze(string fileName, const Module m, checks ~= new UnusedLabelCheck(fileName, moduleScope); if (analysisConfig.unused_variable_check) checks ~= new UnusedVariableCheck(fileName, moduleScope); + if (analysisConfig.long_line_check) + checks ~= new LineLengthCheck(fileName, tokens); version (none) if (analysisConfig.redundant_if_check) checks ~= new IfStatementCheck(fileName, moduleScope);