From a3c4a5384a21d2a2f694c13af7bfa6a621048134 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Tue, 26 May 2015 00:24:21 -0700
Subject: [PATCH 01/25] Starting work on 0.3.0

---
 .gitmodules                            |  6 +++
 containers                             |  1 +
 dsymbol                                |  1 +
 libdparse                              |  2 +-
 makefile                               | 17 ++++++--
 src/analysis/asm_style.d               |  5 ++-
 src/analysis/base.d                    |  6 ++-
 src/analysis/builtin_property_names.d  |  5 ++-
 src/analysis/comma_expression.d        |  5 ++-
 src/analysis/constructors.d            |  5 ++-
 src/analysis/del.d                     |  5 ++-
 src/analysis/duplicate_attribute.d     |  5 ++-
 src/analysis/enumarrayliteral.d        |  5 ++-
 src/analysis/fish.d                    |  5 ++-
 src/analysis/function_attributes.d     |  8 ++--
 src/analysis/if_statements.d           |  7 ++-
 src/analysis/ifelsesame.d              |  7 ++-
 src/analysis/length_subtraction.d      |  5 ++-
 src/analysis/local_imports.d           |  5 ++-
 src/analysis/logic_precedence.d        |  5 ++-
 src/analysis/mismatched_args.d         | 56 ++++++++++++++++++++++++
 src/analysis/numbers.d                 |  5 ++-
 src/analysis/objectconst.d             |  5 ++-
 src/analysis/opequals_without_tohash.d |  5 ++-
 src/analysis/pokemon.d                 |  5 ++-
 src/analysis/range.d                   |  7 +--
 src/analysis/redundant_parens.d        |  5 ++-
 src/analysis/run.d                     | 60 +++++++++++++++-----------
 src/analysis/stats_collector.d         |  2 +-
 src/analysis/style.d                   |  6 +--
 src/analysis/undocumented.d            |  8 ++--
 src/analysis/unmodified.d              |  9 ++--
 src/analysis/unused.d                  |  5 ++-
 src/analysis/unused_label.d            |  5 ++-
 src/main.d                             | 18 +++++---
 35 files changed, 212 insertions(+), 99 deletions(-)
 create mode 160000 containers
 create mode 160000 dsymbol
 create mode 100644 src/analysis/mismatched_args.d

diff --git a/.gitmodules b/.gitmodules
index 85595f2..c977bf8 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -5,3 +5,9 @@
 [submodule "inifiled"]
 	path = inifiled
 	url = https://github.com/burner/inifiled.git
+[submodule "containers"]
+	path = containers
+	url = https://github.com/economicmodeling/containers.git
+[submodule "dsymbol"]
+	path = dsymbol
+	url = https://github.com/Hackerpilot/dsymbol.git
diff --git a/containers b/containers
new file mode 160000
index 0000000..d732a67
--- /dev/null
+++ b/containers
@@ -0,0 +1 @@
+Subproject commit d732a67e76f60fd037547c3ffe8776c6deda6bab
diff --git a/dsymbol b/dsymbol
new file mode 160000
index 0000000..ddf8c97
--- /dev/null
+++ b/dsymbol
@@ -0,0 +1 @@
+Subproject commit ddf8c97753471388303d64a47bdade85cc4de003
diff --git a/libdparse b/libdparse
index 32f6d63..0dccfca 160000
--- a/libdparse
+++ b/libdparse
@@ -1 +1 @@
-Subproject commit 32f6d638e38888e1bb11cf43e93fe2d11132a98f
+Subproject commit 0dccfca0e2a132b3c862a62da1c323ccd24e622d
diff --git a/makefile b/makefile
index 3d2f11e..8ead467 100644
--- a/makefile
+++ b/makefile
@@ -7,12 +7,21 @@ SRC = src/*.d\
 	src/analysis/*.d\
 	libdparse/src/std/*.d\
 	libdparse/src/std/d/*.d\
-	inifiled/source/*.d
-INCLUDE_PATHS = -Ilibdparse/src
+	inifiled/source/*.d\
+	$(shell find dsymbol/src -name "*.d")\
+	containers/src/containers/ttree.d\
+	containers/src/containers/unrolledlist.d\
+	containers/src/containers/hashset.d\
+	containers/src/containers/internal/hash.d\
+	containers/src/containers/internal/node.d\
+	containers/src/containers/internal/storage_type.d\
+	containers/src/memory/allocators.d\
+	containers/src/memory/appender.d
+INCLUDE_PATHS = -Ilibdparse/src -Idsymbol/src -Icontainers/src
 VERSIONS =
 DEBUG_VERSIONS = -version=std_parser_verbose
-DMD_FLAGS = -w -O -release -inline
-#DMD_FLAGS = -w
+#DMD_FLAGS = -w -O -release -inline
+DMD_FLAGS = -w
 
 all: dmdbuild
 ldc: ldcbuild
diff --git a/src/analysis/asm_style.d b/src/analysis/asm_style.d
index 063b48c..6b2344c 100644
--- a/src/analysis/asm_style.d
+++ b/src/analysis/asm_style.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for confusing asm expressions.
@@ -19,9 +20,9 @@ class AsmStyleCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const AsmBrExp brExp)
diff --git a/src/analysis/base.d b/src/analysis/base.d
index f984ef3..adfd3f2 100644
--- a/src/analysis/base.d
+++ b/src/analysis/base.d
@@ -4,6 +4,7 @@ import std.container;
 import std.string;
 import std.d.ast;
 import std.array;
+import dsymbol.scope_ : Scope;
 
 struct Message
 {
@@ -26,8 +27,9 @@ alias MessageSet = RedBlackTree!(Message, comparitor, true);
 abstract class BaseAnalyzer : ASTVisitor
 {
 public:
-	this(string fileName)
+	this(string fileName, const Scope* sc)
 	{
+		this.sc = sc;
 		this.fileName = fileName;
 		_messages = new MessageSet;
 	}
@@ -61,6 +63,8 @@ protected:
 	 */
 	string fileName;
 
+	const(Scope)* sc;
+
 	MessageSet _messages;
 }
 
diff --git a/src/analysis/builtin_property_names.d b/src/analysis/builtin_property_names.d
index c5d62b0..62a14a3 100644
--- a/src/analysis/builtin_property_names.d
+++ b/src/analysis/builtin_property_names.d
@@ -11,6 +11,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_;
 
 /**
  * The following code should be killed with fire:
@@ -29,9 +30,9 @@ class BuiltinPropertyNameCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const FunctionDeclaration fd)
diff --git a/src/analysis/comma_expression.d b/src/analysis/comma_expression.d
index f55e5ec..d628ec7 100644
--- a/src/analysis/comma_expression.d
+++ b/src/analysis/comma_expression.d
@@ -8,6 +8,7 @@ module analysis.comma_expression;
 import std.d.ast;
 import std.d.lexer;
 import analysis.base;
+import dsymbol.scope_;
 
 /**
  * Check for uses of the comma expression.
@@ -16,9 +17,9 @@ class CommaExpressionCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const Expression ex)
diff --git a/src/analysis/constructors.d b/src/analysis/constructors.d
index 3d9eb09..724565e 100644
--- a/src/analysis/constructors.d
+++ b/src/analysis/constructors.d
@@ -5,15 +5,16 @@ import std.d.lexer;
 import std.stdio;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 
 class ConstructorCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const ClassDeclaration classDeclaration)
diff --git a/src/analysis/del.d b/src/analysis/del.d
index c6ee938..be14ad5 100644
--- a/src/analysis/del.d
+++ b/src/analysis/del.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_;
 
 /**
  * Checks for use of the deprecated 'delete' keyword
@@ -18,9 +19,9 @@ class DeleteCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const DeleteExpression d)
diff --git a/src/analysis/duplicate_attribute.d b/src/analysis/duplicate_attribute.d
index 1c1eb6c..8beab67 100644
--- a/src/analysis/duplicate_attribute.d
+++ b/src/analysis/duplicate_attribute.d
@@ -11,6 +11,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 
 /**
@@ -21,9 +22,9 @@ class DuplicateAttributeCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const Declaration node)
diff --git a/src/analysis/enumarrayliteral.d b/src/analysis/enumarrayliteral.d
index f15ada3..9dd4e82 100644
--- a/src/analysis/enumarrayliteral.d
+++ b/src/analysis/enumarrayliteral.d
@@ -9,6 +9,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import std.algorithm : canFind;
+import dsymbol.scope_ : Scope;
 
 void doNothing(string, size_t, size_t, string, bool) {}
 
@@ -16,9 +17,9 @@ class EnumArrayLiteralCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	bool looking = false;
diff --git a/src/analysis/fish.d b/src/analysis/fish.d
index 2bc5dea..6453b06 100644
--- a/src/analysis/fish.d
+++ b/src/analysis/fish.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for use of the deprecated floating point comparison operators.
@@ -20,9 +21,9 @@ class FloatOperatorCheck : BaseAnalyzer
 
 	enum string KEY = "dscanner.deprecated.floating_point_operators";
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const RelExpression r)
diff --git a/src/analysis/function_attributes.d b/src/analysis/function_attributes.d
index 8087310..6da57c0 100644
--- a/src/analysis/function_attributes.d
+++ b/src/analysis/function_attributes.d
@@ -5,11 +5,11 @@
 
 module analysis.function_attributes;
 
+import analysis.base;
 import std.d.ast;
 import std.d.lexer;
-import analysis.base;
-
 import std.stdio;
+import dsymbol.scope_;
 
 /**
  * Prefer
@@ -25,9 +25,9 @@ class FunctionAttributeCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const InterfaceDeclaration dec)
diff --git a/src/analysis/if_statements.d b/src/analysis/if_statements.d
index 73bb8b0..8316ea1 100644
--- a/src/analysis/if_statements.d
+++ b/src/analysis/if_statements.d
@@ -8,15 +8,14 @@ import std.d.ast;
 import std.d.lexer;
 import std.d.formatter;
 import analysis.base;
+import dsymbol.scope_ : Scope;
 
 class IfStatementCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		import std.container.binaryheap : heapify;
-
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const IfStatement ifStatement)
diff --git a/src/analysis/ifelsesame.d b/src/analysis/ifelsesame.d
index f260da0..8d11e95 100644
--- a/src/analysis/ifelsesame.d
+++ b/src/analysis/ifelsesame.d
@@ -6,12 +6,11 @@
 module analysis.ifelsesame;
 
 import std.stdio;
-
 import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
-
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for duplicated code in conditional and logical expressions.
@@ -25,9 +24,9 @@ class IfElseSameCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const IfStatement ifStatement)
diff --git a/src/analysis/length_subtraction.d b/src/analysis/length_subtraction.d
index 0fbef2b..f557bca 100644
--- a/src/analysis/length_subtraction.d
+++ b/src/analysis/length_subtraction.d
@@ -11,6 +11,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_;
 
 
 /**
@@ -20,9 +21,9 @@ class LengthSubtractionCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const AddExpression addExpression)
diff --git a/src/analysis/local_imports.d b/src/analysis/local_imports.d
index 002eda9..9670411 100644
--- a/src/analysis/local_imports.d
+++ b/src/analysis/local_imports.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_;
 
 /**
  * Checks for local imports that import all symbols.
@@ -22,9 +23,9 @@ class LocalImportCheck : BaseAnalyzer
 	/**
 	 * Construct with the given file name.
 	 */
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	mixin visitThing!StructBody;
diff --git a/src/analysis/logic_precedence.d b/src/analysis/logic_precedence.d
index c78dc6a..15948dc 100644
--- a/src/analysis/logic_precedence.d
+++ b/src/analysis/logic_precedence.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_;
 
 /**
  * Checks for code with confusing && and || operator precedence
@@ -24,9 +25,9 @@ class LogicPrecedenceCheck : BaseAnalyzer
 
 	enum string KEY = "dscanner.confusing.logical_precedence";
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const OrOrExpression orOr)
diff --git a/src/analysis/mismatched_args.d b/src/analysis/mismatched_args.d
new file mode 100644
index 0000000..7848b04
--- /dev/null
+++ b/src/analysis/mismatched_args.d
@@ -0,0 +1,56 @@
+module analysis.mismatched_args;
+
+struct ArgMismatch
+{
+	size_t argIndex;
+	size_t paramIndex;
+}
+
+ArgMismatch[] compareArgsToParams(const string[] params, const string[] args) pure
+in
+{
+	assert(args.length == params.length);
+}
+body
+{
+	ArgMismatch[] retVal;
+	foreach (i, arg; args)
+	{
+		if (arg is null || arg == params[i])
+			continue;
+		foreach (j, param; params)
+			if (param == arg)
+				retVal ~= ArgMismatch(i, j);
+	}
+	return retVal;
+}
+
+string createWarningFromMismatch(ref const ArgMismatch mismatch, const string commonName) pure
+{
+	import std.format : format;
+
+	return "Argument %d is named '%s', but this is the name of parameter %d".format(
+		mismatch.argIndex + 1, commonName, mismatch.paramIndex + 1);
+}
+
+unittest
+{
+	{
+		string[] args = ["a", "b", "c"];
+		string[] params = ["a", "b", "c"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == []);
+	}
+	{
+		string[] args = ["a", "c", "b"];
+		string[] params = ["a", "b", "c"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == [ArgMismatch(1, 2), ArgMismatch(2, 1)]);
+	}
+	{
+		string[] args = ["a", "c", "b"];
+		string[] params = ["alpha", "bravo", "c"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == [ArgMismatch(1, 2)]);
+	}
+}
diff --git a/src/analysis/numbers.d b/src/analysis/numbers.d
index bc67da3..9cb1041 100644
--- a/src/analysis/numbers.d
+++ b/src/analysis/numbers.d
@@ -11,6 +11,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for long and hard-to-read number literals
@@ -23,9 +24,9 @@ public:
 	/**
 	 * Constructs the style checker with the given file name.
 	 */
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const Token t)
diff --git a/src/analysis/objectconst.d b/src/analysis/objectconst.d
index f46d1a6..0e7778c 100644
--- a/src/analysis/objectconst.d
+++ b/src/analysis/objectconst.d
@@ -11,6 +11,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks that opEquals, opCmp, toHash, and toString are either const,
@@ -20,9 +21,9 @@ class ObjectConstCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	mixin visitTemplate!ClassDeclaration;
diff --git a/src/analysis/opequals_without_tohash.d b/src/analysis/opequals_without_tohash.d
index 290a805..e9fd138 100644
--- a/src/analysis/opequals_without_tohash.d
+++ b/src/analysis/opequals_without_tohash.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for when a class/struct has the method opEquals without toHash, or
@@ -19,9 +20,9 @@ class OpEqualsWithoutToHashCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const ClassDeclaration node)
diff --git a/src/analysis/pokemon.d b/src/analysis/pokemon.d
index 7d61571..b20e41e 100644
--- a/src/analysis/pokemon.d
+++ b/src/analysis/pokemon.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 
 /**
@@ -30,9 +31,9 @@ class PokemonExceptionCheck : BaseAnalyzer
 
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const LastCatch lc)
diff --git a/src/analysis/range.d b/src/analysis/range.d
index 1d2644e..1d656fd 100644
--- a/src/analysis/range.d
+++ b/src/analysis/range.d
@@ -10,6 +10,7 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for .. expressions where the left side is larger than the right. This
@@ -26,9 +27,9 @@ class BackwardsRangeCheck : BaseAnalyzer
 	 * Params:
 	 *     fileName = the name of the file being analyzed
 	 */
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const ForeachStatement foreachStatement)
@@ -56,7 +57,7 @@ class BackwardsRangeCheck : BaseAnalyzer
 
 	override void visit(const AddExpression add)
 	{
-		auto s = state;
+		immutable s = state;
 		state = State.ignore;
 		add.accept(this);
 		state = s;
diff --git a/src/analysis/redundant_parens.d b/src/analysis/redundant_parens.d
index 88c8c5f..a036d6f 100644
--- a/src/analysis/redundant_parens.d
+++ b/src/analysis/redundant_parens.d
@@ -8,14 +8,15 @@ module analysis.redundant_parens;
 import std.d.ast;
 import std.d.lexer;
 import analysis.base;
+import dsymbol.scope_ : Scope;
 
 class RedundantParenCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const IfStatement statement)
diff --git a/src/analysis/run.d b/src/analysis/run.d
index 2d1a9e6..647e607 100644
--- a/src/analysis/run.d
+++ b/src/analysis/run.d
@@ -14,6 +14,8 @@ import std.array;
 import std.d.lexer;
 import std.d.parser;
 import std.d.ast;
+import std.allocator : CAllocatorImpl;
+import std.typecons:scoped;
 
 import analysis.config;
 import analysis.base;
@@ -44,6 +46,11 @@ import analysis.unmodified;
 import analysis.if_statements;
 import analysis.redundant_parens;
 
+import memory.allocators:BlockAllocator;
+
+import dsymbol.scope_;
+import dsymbol.conversion;
+
 bool first = true;
 
 void messageFunction(string fileName, size_t line, size_t column, string message,
@@ -166,33 +173,36 @@ MessageSet analyze(string fileName, const Module m,
 	if (!staticAnalyze)
 		return null;
 
+	auto allocator = scoped!(CAllocatorImpl!(BlockAllocator!(1024 * 16)))();
+	const(Scope)* moduleScope = generateAutocompleteTrees(m, allocator);
+
 	BaseAnalyzer[] checks;
 
-	if (analysisConfig.style_check) checks ~= new StyleChecker(fileName);
-	if (analysisConfig.enum_array_literal_check) checks ~= new EnumArrayLiteralCheck(fileName);
-	if (analysisConfig.exception_check) checks ~= new PokemonExceptionCheck(fileName);
-	if (analysisConfig.delete_check) checks ~= new DeleteCheck(fileName);
-	if (analysisConfig.float_operator_check) checks ~= new FloatOperatorCheck(fileName);
-	if (analysisConfig.number_style_check) checks ~= new NumberStyleCheck(fileName);
-	if (analysisConfig.object_const_check) checks ~= new ObjectConstCheck(fileName);
-	if (analysisConfig.backwards_range_check) checks ~= new BackwardsRangeCheck(fileName);
-	if (analysisConfig.if_else_same_check) checks ~= new IfElseSameCheck(fileName);
-	if (analysisConfig.constructor_check) checks ~= new ConstructorCheck(fileName);
-	if (analysisConfig.unused_label_check) checks ~= new UnusedLabelCheck(fileName);
-	if (analysisConfig.unused_variable_check) checks ~= new UnusedVariableCheck(fileName);
-	if (analysisConfig.duplicate_attribute) checks ~= new DuplicateAttributeCheck(fileName);
-	if (analysisConfig.opequals_tohash_check) checks ~= new OpEqualsWithoutToHashCheck(fileName);
-	if (analysisConfig.length_subtraction_check) checks ~= new LengthSubtractionCheck(fileName);
-	if (analysisConfig.builtin_property_names_check) checks ~= new BuiltinPropertyNameCheck(fileName);
-	if (analysisConfig.asm_style_check) checks ~= new AsmStyleCheck(fileName);
-	if (analysisConfig.logical_precedence_check) checks ~= new LogicPrecedenceCheck(fileName);
-	if (analysisConfig.undocumented_declaration_check) checks ~= new UndocumentedDeclarationCheck(fileName);
-	if (analysisConfig.function_attribute_check) checks ~= new FunctionAttributeCheck(fileName);
-	if (analysisConfig.comma_expression_check) checks ~= new CommaExpressionCheck(fileName);
-	if (analysisConfig.local_import_check) checks ~= new LocalImportCheck(fileName);
-	if (analysisConfig.could_be_immutable_check) checks ~= new UnmodifiedFinder(fileName);
-	if (analysisConfig.redundant_parens_check) checks ~= new RedundantParenCheck(fileName);
-	version(none) if (analysisConfig.redundant_if_check) checks ~= new IfStatementCheck(fileName);
+	if (analysisConfig.style_check) checks ~= new StyleChecker(fileName, moduleScope);
+	if (analysisConfig.enum_array_literal_check) checks ~= new EnumArrayLiteralCheck(fileName, moduleScope);
+	if (analysisConfig.exception_check) checks ~= new PokemonExceptionCheck(fileName, moduleScope);
+	if (analysisConfig.delete_check) checks ~= new DeleteCheck(fileName, moduleScope);
+	if (analysisConfig.float_operator_check) checks ~= new FloatOperatorCheck(fileName, moduleScope);
+	if (analysisConfig.number_style_check) checks ~= new NumberStyleCheck(fileName, moduleScope);
+	if (analysisConfig.object_const_check) checks ~= new ObjectConstCheck(fileName, moduleScope);
+	if (analysisConfig.backwards_range_check) checks ~= new BackwardsRangeCheck(fileName, moduleScope);
+	if (analysisConfig.if_else_same_check) checks ~= new IfElseSameCheck(fileName, moduleScope);
+	if (analysisConfig.constructor_check) checks ~= new ConstructorCheck(fileName, moduleScope);
+	if (analysisConfig.unused_label_check) checks ~= new UnusedLabelCheck(fileName, moduleScope);
+	if (analysisConfig.unused_variable_check) checks ~= new UnusedVariableCheck(fileName, moduleScope);
+	if (analysisConfig.duplicate_attribute) checks ~= new DuplicateAttributeCheck(fileName, moduleScope);
+	if (analysisConfig.opequals_tohash_check) checks ~= new OpEqualsWithoutToHashCheck(fileName, moduleScope);
+	if (analysisConfig.length_subtraction_check) checks ~= new LengthSubtractionCheck(fileName, moduleScope);
+	if (analysisConfig.builtin_property_names_check) checks ~= new BuiltinPropertyNameCheck(fileName, moduleScope);
+	if (analysisConfig.asm_style_check) checks ~= new AsmStyleCheck(fileName, moduleScope);
+	if (analysisConfig.logical_precedence_check) checks ~= new LogicPrecedenceCheck(fileName, moduleScope);
+	if (analysisConfig.undocumented_declaration_check) checks ~= new UndocumentedDeclarationCheck(fileName, moduleScope);
+	if (analysisConfig.function_attribute_check) checks ~= new FunctionAttributeCheck(fileName, moduleScope);
+	if (analysisConfig.comma_expression_check) checks ~= new CommaExpressionCheck(fileName, moduleScope);
+	if (analysisConfig.local_import_check) checks ~= new LocalImportCheck(fileName, moduleScope);
+	if (analysisConfig.could_be_immutable_check) checks ~= new UnmodifiedFinder(fileName, moduleScope);
+	if (analysisConfig.redundant_parens_check) checks ~= new RedundantParenCheck(fileName, moduleScope);
+	version(none) if (analysisConfig.redundant_if_check) checks ~= new IfStatementCheck(fileName, moduleScope);
 
 	foreach (check; checks)
 	{
diff --git a/src/analysis/stats_collector.d b/src/analysis/stats_collector.d
index c3cc6fd..f33be48 100644
--- a/src/analysis/stats_collector.d
+++ b/src/analysis/stats_collector.d
@@ -15,7 +15,7 @@ class StatsCollector : BaseAnalyzer
 
 	this(string fileName)
 	{
-		super(fileName);
+		super(fileName, null);
 	}
 
 	override void visit(const Statement statement)
diff --git a/src/analysis/style.d b/src/analysis/style.d
index 6d30e80..47b13bb 100644
--- a/src/analysis/style.d
+++ b/src/analysis/style.d
@@ -13,8 +13,8 @@ import std.array;
 import std.conv;
 import std.format;
 import analysis.helpers;
-
 import analysis.base;
+import dsymbol.scope_ : Scope;
 
 class StyleChecker : BaseAnalyzer
 {
@@ -25,9 +25,9 @@ class StyleChecker : BaseAnalyzer
 	enum string moduleNameRegex = `^[\p{Ll}_\d]+$`;
 	enum string KEY = "dscanner.style.phobos_naming_convention";
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const ModuleDeclaration dec)
diff --git a/src/analysis/undocumented.d b/src/analysis/undocumented.d
index 165f807..e844464 100644
--- a/src/analysis/undocumented.d
+++ b/src/analysis/undocumented.d
@@ -5,10 +5,10 @@
 
 module analysis.undocumented;
 
+import analysis.base;
+import dsymbol.scope_ : Scope;
 import std.d.ast;
 import std.d.lexer;
-import analysis.base;
-
 import std.stdio;
 
 /**
@@ -19,9 +19,9 @@ class UndocumentedDeclarationCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const Module mod)
diff --git a/src/analysis/unmodified.d b/src/analysis/unmodified.d
index b5621ce..ce9998d 100644
--- a/src/analysis/unmodified.d
+++ b/src/analysis/unmodified.d
@@ -4,10 +4,11 @@
 //          http://www.boost.org/LICENSE_1_0.txt)
 module analysis.unmodified;
 
+import analysis.base;
+import dsymbol.scope_ : Scope;
 import std.container;
 import std.d.ast;
 import std.d.lexer;
-import analysis.base;
 
 /**
  * Checks for variables that could have been declared const or immutable
@@ -17,9 +18,9 @@ class UnmodifiedFinder:BaseAnalyzer
 	alias visit = BaseAnalyzer.visit;
 
 	///
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	override void visit(const Module mod)
@@ -41,7 +42,7 @@ class UnmodifiedFinder:BaseAnalyzer
 	override void visit(const StructBody structBody)
 	{
 		pushScope();
-		auto oldBlockStatementDepth = blockStatementDepth;
+		immutable oldBlockStatementDepth = blockStatementDepth;
 		blockStatementDepth = 0;
 		structBody.accept(this);
 		blockStatementDepth = oldBlockStatementDepth;
diff --git a/src/analysis/unused.d b/src/analysis/unused.d
index 7b23dbe..49853b4 100644
--- a/src/analysis/unused.d
+++ b/src/analysis/unused.d
@@ -10,6 +10,7 @@ import std.d.lexer;
 import analysis.base;
 import std.container;
 import std.regex : Regex, regex, matchAll;
+import dsymbol.scope_ : Scope;
 
 /**
  * Checks for unused variables.
@@ -22,9 +23,9 @@ class UnusedVariableCheck : BaseAnalyzer
 	 * Params:
 	 *     fileName = the name of the file being analyzed
 	 */
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 		re = regex("[\\p{Alphabetic}_][\\w_]*");
 	}
 
diff --git a/src/analysis/unused_label.d b/src/analysis/unused_label.d
index 32c0cc7..0f9ac56 100644
--- a/src/analysis/unused_label.d
+++ b/src/analysis/unused_label.d
@@ -9,14 +9,15 @@ import std.d.ast;
 import std.d.lexer;
 import analysis.base;
 import analysis.helpers;
+import dsymbol.scope_ : Scope;
 
 class UnusedLabelCheck : BaseAnalyzer
 {
 	alias visit = BaseAnalyzer.visit;
 
-	this(string fileName)
+	this(string fileName, const(Scope)* sc)
 	{
-		super(fileName);
+		super(fileName, sc);
 	}
 
 	static struct Label
diff --git a/src/main.d b/src/main.d
index 69f85f2..54ae665 100644
--- a/src/main.d
+++ b/src/main.d
@@ -1,4 +1,4 @@
-//          Copyright Brian Schott (Hackerpilot) 2012.
+//          Copyright Brian Schott (Hackerpilot) 2012-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)
@@ -31,6 +31,8 @@ import dscanner_version;
 
 import inifiled;
 
+import dsymbol.modulecache;
+
 int main(string[] args)
 {
 	version (unittest)
@@ -65,6 +67,7 @@ int run(string[] args)
 	string configLocation;
 	bool printVersion;
 	bool explore;
+	string[] importPaths;
 
 	try
 	{
@@ -75,7 +78,7 @@ int run(string[] args)
 			"ast|xml", &ast, "imports|i", &imports, "outline|o", &outline,
 			"tokenDump", &tokenDump, "styleCheck|S", &styleCheck,
 			"defaultConfig", &defaultConfig, "declaration|d", &symbolName,
-			"config", &configLocation, "report", &report,
+			"config", &configLocation, "report", &report, "I", &importPaths,
 			"version", &printVersion, "muffinButton", &muffin, "explore", &explore);
 	}
 	catch (ConvException e)
@@ -121,7 +124,13 @@ int run(string[] args)
 		return 0;
 	}
 
-	auto optionCount = count!"a"([sloc, highlight, ctags, tokenCount,
+	const(string[]) absImportPaths = importPaths.map!(
+		a => a.absolutePath().buildNormalizedPath()).array();
+
+	if (absImportPaths.length)
+		ModuleCache.addImportPaths(absImportPaths);
+
+	immutable optionCount = count!"a"([sloc, highlight, ctags, tokenCount,
 		syntaxCheck, ast, imports, outline, tokenDump, styleCheck, defaultConfig,
 		report, symbolName !is null, etags, etagsAll]);
 	if (optionCount > 1)
@@ -274,7 +283,6 @@ int run(string[] args)
 	return 0;
 }
 
-
 string[] expandArgs(string[] args)
 {
 	// isFile can throw if it's a broken symlink.
@@ -289,7 +297,7 @@ string[] expandArgs(string[] args)
 			return false;
 		}
 	}
-	
+
 	string[] rVal;
 	if (args.length == 1)
 		args ~= ".";

From 3828fa1b47bc775a2184041feedad3a894ecf92e Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Thu, 28 May 2015 10:21:34 -0700
Subject: [PATCH 02/25] Update dsymbol

---
 dsymbol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dsymbol b/dsymbol
index ddf8c97..0bcc733 160000
--- a/dsymbol
+++ b/dsymbol
@@ -1 +1 @@
-Subproject commit ddf8c97753471388303d64a47bdade85cc4de003
+Subproject commit 0bcc733665e6d6f1efbe34a03fe8cf929b6d331e

From 6b18fa8640e25986982fa31b0c39461445600066 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Thu, 28 May 2015 10:24:49 -0700
Subject: [PATCH 03/25] #244

---
 src/analysis/config.d          |   3 +
 src/analysis/mismatched_args.d | 224 +++++++++++++++++++++++++++------
 src/analysis/run.d             |   2 +
 3 files changed, 189 insertions(+), 40 deletions(-)

diff --git a/src/analysis/config.d b/src/analysis/config.d
index 8136f05..7a81877 100644
--- a/src/analysis/config.d
+++ b/src/analysis/config.d
@@ -92,4 +92,7 @@ struct StaticAnalysisConfig
 
 	@INI("Checks for redundant parenthesis")
 	bool redundant_parens_check;
+
+	@INI("Checks for mismatched argument and parameter names")
+	bool mismatched_args_check;
 }
diff --git a/src/analysis/mismatched_args.d b/src/analysis/mismatched_args.d
index 7848b04..bdbb14d 100644
--- a/src/analysis/mismatched_args.d
+++ b/src/analysis/mismatched_args.d
@@ -1,56 +1,200 @@
 module analysis.mismatched_args;
 
+import analysis.base : BaseAnalyzer;
+import dsymbol.scope_;
+import dsymbol.symbol;
+import std.d.ast;
+import std.d.lexer : tok;
+
+/// Checks for mismatched argument and parameter names
+final class MismatchedArgumentCheck : BaseAnalyzer
+{
+	///
+    this(string fileName, const Scope* sc)
+    {
+        super(fileName, sc);
+    }
+
+	override void visit(const FunctionCallExpression fce)
+	{
+		import std.typecons : scoped;
+		import std.algorithm.iteration : each, map;
+		import std.array : array;
+
+		if (fce.arguments is null)
+			return;
+		auto argVisitor = scoped!ArgVisitor;
+		argVisitor.visit(fce.arguments);
+		const istring[] args = argVisitor.args;
+
+		auto identVisitor = scoped!IdentVisitor;
+		identVisitor.visit(fce.unaryExpression);
+
+		DSymbol* sym = resolveSymbol(sc, identVisitor.names);
+		const istring[] params = sym is null ? [] : sym.parts[].map!(a => a.name).array();
+		const ArgMismatch[] mismatches = compareArgsToParams(params, args);
+		foreach(size_t i, ref const mm; mismatches)
+			addErrorMessage(argVisitor.lines[i], argVisitor.columns[i], KEY,
+				createWarningFromMismatch(mm));
+	}
+
+	alias visit = ASTVisitor.visit;
+
+private:
+
+	enum KEY = "dscanner.confusing.argument_parameter_mismatch";
+}
+
+final class IdentVisitor : ASTVisitor
+{
+	override void visit(const IdentifierOrTemplateInstance ioti)
+	{
+		import dsymbol.string_interning : internString;
+
+		if (ioti.identifier != tok!"")
+			names ~= internString(ioti.identifier.text);
+		else
+			names ~= internString(ioti.templateInstance.identifier.text);
+	}
+
+	override void visit(const Arguments)
+	{
+	}
+
+	override void visit(const IndexExpression ie)
+	{
+		if (ie.unaryExpression !is null)
+			visit(ie.unaryExpression);
+	}
+
+	alias visit = ASTVisitor.visit;
+
+	istring[] names;
+}
+
+final class ArgVisitor : ASTVisitor
+{
+	override void visit(const ArgumentList al)
+	{
+		foreach (a; al.items)
+		{
+			auto u = cast(UnaryExpression) a;
+			if (u !is null)
+				visit(u);
+			else
+			{
+				args ~= istring.init;
+				lines ~= size_t.max;
+				columns ~= size_t.max;
+			}
+		}
+	}
+
+    override void visit(const UnaryExpression unary)
+    {
+		import dsymbol.string_interning : internString;
+
+		if (unary.primaryExpression is null)
+			return;
+		if (unary.primaryExpression.identifierOrTemplateInstance is null)
+			return;
+		if (unary.primaryExpression.identifierOrTemplateInstance.identifier == tok!"")
+			return;
+		immutable t = unary.primaryExpression.identifierOrTemplateInstance.identifier;
+		lines ~= t.line;
+		columns ~= t.column;
+		args ~= internString(t.text);
+    }
+
+	alias visit = ASTVisitor.visit;
+
+	size_t[] lines;
+	size_t[] columns;
+    istring[] args;
+}
+
+DSymbol* resolveSymbol(const Scope* sc, const istring[] symbolChain)
+{
+	import std.array:empty;
+
+	DSymbol*[] s = sc.getSymbolsByName(symbolChain[0]);
+	if (s.empty)
+		return null;
+
+	DSymbol* sym = s[0];
+	foreach (i; 1 .. symbolChain.length)
+	{
+		if (sym.kind == CompletionKind.variableName || sym.kind == CompletionKind.memberVariableName
+				|| sym.kind == CompletionKind.functionName)
+			sym = sym.type;
+		if (sym is null)
+			return null;
+		auto p = sym.getPartsByName(symbolChain[i]);
+		if (p.empty)
+			return null;
+		sym = p[0];
+	}
+	return sym;
+}
+
 struct ArgMismatch
 {
-	size_t argIndex;
-	size_t paramIndex;
+    size_t argIndex;
+    size_t paramIndex;
+	string name;
 }
 
-ArgMismatch[] compareArgsToParams(const string[] params, const string[] args) pure
-in
+const(ArgMismatch[]) compareArgsToParams(const istring[] params, const istring[] args) pure
 {
-	assert(args.length == params.length);
-}
-body
-{
-	ArgMismatch[] retVal;
-	foreach (i, arg; args)
-	{
-		if (arg is null || arg == params[i])
-			continue;
-		foreach (j, param; params)
-			if (param == arg)
-				retVal ~= ArgMismatch(i, j);
-	}
-	return retVal;
+	if(args.length != params.length)
+		return [];
+    ArgMismatch[] retVal;
+    foreach (i, arg; args)
+    {
+        if (arg is null || arg == params[i])
+            continue;
+        foreach (j, param; params)
+            if (param == arg)
+				retVal ~= ArgMismatch(i, j, arg);
+    }
+    return retVal;
 }
 
-string createWarningFromMismatch(ref const ArgMismatch mismatch, const string commonName) pure
+string createWarningFromMismatch(const ArgMismatch mismatch) pure
 {
-	import std.format : format;
+    import std.format : format;
 
-	return "Argument %d is named '%s', but this is the name of parameter %d".format(
-		mismatch.argIndex + 1, commonName, mismatch.paramIndex + 1);
+    return "Argument %d is named '%s', but this is the name of parameter %d"
+        .format(mismatch.argIndex + 1, mismatch.name, mismatch.paramIndex + 1);
 }
 
 unittest
 {
-	{
-		string[] args = ["a", "b", "c"];
-		string[] params = ["a", "b", "c"];
-		immutable res = compareArgsToParams(params, args);
-		assert(res == []);
-	}
-	{
-		string[] args = ["a", "c", "b"];
-		string[] params = ["a", "b", "c"];
-		immutable res = compareArgsToParams(params, args);
-		assert(res == [ArgMismatch(1, 2), ArgMismatch(2, 1)]);
-	}
-	{
-		string[] args = ["a", "c", "b"];
-		string[] params = ["alpha", "bravo", "c"];
-		immutable res = compareArgsToParams(params, args);
-		assert(res == [ArgMismatch(1, 2)]);
-	}
+    {
+        string[] args = ["a", "b", "c"];
+        string[] params = ["a", "b", "c"];
+        immutable res = compareArgsToParams(params, args);
+        assert(res == []);
+    }
+
+    {
+        string[] args = ["a", "c", "b"];
+        string[] params = ["a", "b", "c"];
+        immutable res = compareArgsToParams(params, args);
+        assert(res == [ArgMismatch(1, 2), ArgMismatch(2, 1)]);
+    }
+
+    {
+        string[] args = ["a", "c", "b"];
+        string[] params = ["alpha", "bravo", "c"];
+        immutable res = compareArgsToParams(params, args);
+        assert(res == [ArgMismatch(1, 2)]);
+    }
+
+    {
+        string[] args = ["a", "b"];
+        string[] params = [null, "b"];
+        immutable res = compareArgsToParams(params, args);
+        assert(res == []);
+    }
 }
diff --git a/src/analysis/run.d b/src/analysis/run.d
index 647e607..1aad48a 100644
--- a/src/analysis/run.d
+++ b/src/analysis/run.d
@@ -45,6 +45,7 @@ import analysis.local_imports;
 import analysis.unmodified;
 import analysis.if_statements;
 import analysis.redundant_parens;
+import analysis.mismatched_args;
 
 import memory.allocators:BlockAllocator;
 
@@ -202,6 +203,7 @@ MessageSet analyze(string fileName, const Module m,
 	if (analysisConfig.local_import_check) checks ~= new LocalImportCheck(fileName, moduleScope);
 	if (analysisConfig.could_be_immutable_check) checks ~= new UnmodifiedFinder(fileName, moduleScope);
 	if (analysisConfig.redundant_parens_check) checks ~= new RedundantParenCheck(fileName, moduleScope);
+	if (analysisConfig.mismatched_args_check) checks ~= new MismatchedArgumentCheck(fileName, moduleScope);
 	version(none) if (analysisConfig.redundant_if_check) checks ~= new IfStatementCheck(fileName, moduleScope);
 
 	foreach (check; checks)

From 64cae9357399b59da0b4f198de1983ab951ce845 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 29 May 2015 08:42:06 -0700
Subject: [PATCH 04/25] Update dsymbol

---
 dsymbol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dsymbol b/dsymbol
index 0bcc733..393da96 160000
--- a/dsymbol
+++ b/dsymbol
@@ -1 +1 @@
-Subproject commit 0bcc733665e6d6f1efbe34a03fe8cf929b6d331e
+Subproject commit 393da9696f81d0692f8022e2d5d40dc662d984f9

From f6dde09c57c147e9104e8a7e0ac213e9e1aaa105 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 29 May 2015 08:43:06 -0700
Subject: [PATCH 05/25] Comment cleanup

---
 src/analysis/unused.d | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/analysis/unused.d b/src/analysis/unused.d
index 49853b4..53a81de 100644
--- a/src/analysis/unused.d
+++ b/src/analysis/unused.d
@@ -1,8 +1,7 @@
-//          Copyright Brian Schott (Hackerpilot) 2014.
+//          Copyright Brian Schott (Hackerpilot) 2014-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.unused;
 
 import std.d.ast;
@@ -278,7 +277,6 @@ class UnusedVariableCheck : BaseAnalyzer
 		import std.array : array;
 		if (parameter.name != tok!"")
 		{
-//			stderr.writeln("Adding parameter ", parameter.name.text);
 			immutable bool isRef = canFind(parameter.parameterAttributes, cast(IdType) tok!"ref")
 				|| canFind(parameter.parameterAttributes, cast(IdType) tok!"in")
 				|| canFind(parameter.parameterAttributes, cast(IdType) tok!"out");
@@ -398,4 +396,3 @@ private:
 
 	Regex!char re;
 }
-

From 7e0d0dd13030b9aa203c2b257ee7c5436884918b Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 29 May 2015 08:45:27 -0700
Subject: [PATCH 06/25] Improve accuracy of unmodified variable check

---
 src/analysis/unmodified.d | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/analysis/unmodified.d b/src/analysis/unmodified.d
index ce9998d..4067ab1 100644
--- a/src/analysis/unmodified.d
+++ b/src/analysis/unmodified.d
@@ -59,7 +59,7 @@ class UnmodifiedFinder:BaseAnalyzer
 				if (initializedFromCast(d.initializer))
 					continue;
 				tree[$ - 1].insert(new VariableInfo(d.name.text, d.name.line,
-					d.name.column));
+					d.name.column, isValueTypeSimple(dec.type)));
 			}
 		}
 		dec.accept(this);
@@ -89,7 +89,9 @@ class UnmodifiedFinder:BaseAnalyzer
 		if (assignExpression.operator != tok!"")
 		{
 			interest++;
+			guaranteeUse++;
 			assignExpression.ternaryExpression.accept(this);
+			guaranteeUse--;
 			interest--;
 			assignExpression.assignExpression.accept(this);
 		}
@@ -133,10 +135,13 @@ class UnmodifiedFinder:BaseAnalyzer
 	override void visit(const UnaryExpression unary)
 	{
 		if (unary.prefix == tok!"++" || unary.prefix == tok!"--"
-			|| unary.suffix == tok!"++" || unary.suffix == tok!"--")
+			|| unary.suffix == tok!"++" || unary.suffix == tok!"--"
+			|| unary.prefix == tok!"*" || unary.prefix == tok!"&")
 		{
 			interest++;
+			guaranteeUse++;
 			unary.accept(this);
+			guaranteeUse--;
 			interest--;
 		}
 		else
@@ -168,10 +173,14 @@ private:
 
 	void variableMightBeModified(string name)
 	{
-//		import std.stdio : stderr;
-//		stderr.writeln("Marking ", name, " as possibly modified");
 		size_t index = tree.length - 1;
 		auto vi = VariableInfo(name);
+		if (guaranteeUse == 0)
+		{
+			auto r = tree[index].equalRange(&vi);
+			if (!r.empty && r.front.isValueType)
+				return;
+		}
 		while (true)
 		{
 			if (tree[index].removeKey(&vi) != 0 || index == 0)
@@ -236,6 +245,7 @@ private:
 		string name;
 		size_t line;
 		size_t column;
+		bool isValueType;
 	}
 
 	void popScope()
@@ -260,8 +270,16 @@ private:
 
 	int interest;
 
+	int guaranteeUse;
+
 	int isImmutable;
 
 	RedBlackTree!(VariableInfo*, "a.name < b.name")[] tree;
 }
 
+bool isValueTypeSimple(const Type type) pure nothrow @nogc
+{
+	if (type.type2 is null)
+		return false;
+	return type.type2.builtinType != tok!"" && type.typeSuffixes.length == 0;
+}

From faf5816322b30a4e0b7b1bd168214d8ab859bc19 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 29 May 2015 08:47:01 -0700
Subject: [PATCH 07/25] Fix #260 by skipping declarations inside of
 version(unittest) or version(none)

---
 src/analysis/undocumented.d | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/analysis/undocumented.d b/src/analysis/undocumented.d
index e844464..d336b04 100644
--- a/src/analysis/undocumented.d
+++ b/src/analysis/undocumented.d
@@ -89,6 +89,15 @@ class UndocumentedDeclarationCheck : BaseAnalyzer
 		}
 	}
 
+	override void visit(const ConditionalDeclaration cond)
+	{
+		const VersionCondition ver = cond.compileCondition.versionCondition;
+		if (ver is null || ver.token != tok!"unittest" && ver.token.text != "none")
+			cond.accept(this);
+		else if (cond.falseDeclaration !is null)
+			visit(cond.falseDeclaration);
+	}
+
 	override void visit(const FunctionBody fb) {}
 	override void visit(const Unittest u) {}
 

From e48dc0acc5cb1603997cf7333768a873b8dae702 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 29 May 2015 08:47:57 -0700
Subject: [PATCH 08/25] Enable function parameter caching for cached symbols

---
 src/main.d | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main.d b/src/main.d
index 54ae665..3594b45 100644
--- a/src/main.d
+++ b/src/main.d
@@ -127,6 +127,7 @@ int run(string[] args)
 	const(string[]) absImportPaths = importPaths.map!(
 		a => a.absolutePath().buildNormalizedPath()).array();
 
+	ModuleCache.includeParameterSymbols = true;
 	if (absImportPaths.length)
 		ModuleCache.addImportPaths(absImportPaths);
 

From 4e1cdf23becb9f7adfb13bfed07288773d2b96d5 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 03:58:37 -0700
Subject: [PATCH 09/25] Fix null pointer crash

---
 dsymbol                | 2 +-
 makefile               | 2 +-
 src/analysis/helpers.d | 2 +-
 src/main.d             | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dsymbol b/dsymbol
index 1c5579d..e83afca 160000
--- a/dsymbol
+++ b/dsymbol
@@ -1 +1 @@
-Subproject commit 1c5579db6c1d88a097d46f5bee5ae1e2cf8fff02
+Subproject commit e83afca7cf2cac48084ba294926d4dd24945dc1a
diff --git a/makefile b/makefile
index 9f271b7..f3112c4 100644
--- a/makefile
+++ b/makefile
@@ -30,7 +30,7 @@ githash:
 	git log -1 --format="%H" > githash.txt
 
 debug:
-	${DC} -w -g -ofdsc ${VERSIONS} ${DEBUG_VERSIONS} ${INCLUDE_PATHS} ${SRC}
+	${DC} -w -g -J. -ofdsc ${VERSIONS} ${DEBUG_VERSIONS} ${INCLUDE_PATHS} ${SRC}
 
 dmdbuild: githash $(SRC)
 	mkdir -p bin
diff --git a/src/analysis/helpers.d b/src/analysis/helpers.d
index 7ffbd2d..7368d8a 100644
--- a/src/analysis/helpers.d
+++ b/src/analysis/helpers.d
@@ -59,7 +59,7 @@ void assertAnalyzerWarnings(string code, const StaticAnalysisConfig config, stri
 	ParseAllocator p = new ParseAllocator;
 	const(Module) m = parseModule(file, cast(ubyte[]) code, p, cache, false);
 
-	ModuleCache moduleCache;
+	auto moduleCache = ModuleCache(p);
 
 	// Run the code and get any warnings
 	MessageSet rawWarnings = analyze("test", m, config, moduleCache);
diff --git a/src/main.d b/src/main.d
index 8a0adec..ddc1f64 100644
--- a/src/main.d
+++ b/src/main.d
@@ -118,7 +118,7 @@ int main(string[] args)
 	const(string[]) absImportPaths = importPaths.map!(
 		a => a.absolutePath().buildNormalizedPath()).array();
 
-	ModuleCache moduleCache;
+	auto moduleCache = ModuleCache(new dsymbol.modulecache.ASTAllocator);
 
 	if (absImportPaths.length)
 		moduleCache.addImportPaths(absImportPaths);

From 435590070cf09289ffea393e92fdd0c3c423917e Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 03:59:00 -0700
Subject: [PATCH 10/25] Fix #271 by updating the parser

---
 libdparse | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libdparse b/libdparse
index 071e0ce..a059356 160000
--- a/libdparse
+++ b/libdparse
@@ -1 +1 @@
-Subproject commit 071e0cee083a0392d9226fdfba593dd86c21d412
+Subproject commit a059356c94e949625417ea98c9c1c59186fa285f

From 6dc1cb91911e3238807357dcfa138733a0c1ceff Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 03:59:32 -0700
Subject: [PATCH 11/25] Update .gitignore

---
 .gitignore | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 9a4f0d9..15b3611 100755
--- a/.gitignore
+++ b/.gitignore
@@ -27,8 +27,11 @@ dscanner-report.json
 *.exe
 obj
 
-#debug build
+# debug build
 dsc
 
 # Git hash
 githash.txt
+
+# GDB history
+.gdb_history

From c09abbdab69c0d66768c4bc5fa029b9375dec70c Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 04:06:18 -0700
Subject: [PATCH 12/25] Fix range error in mismatched argument checker, disable
 logging from dsymbol

---
 makefile                       |   2 +-
 src/analysis/mismatched_args.d | 105 +++++++++++++++++----------------
 2 files changed, 55 insertions(+), 52 deletions(-)

diff --git a/makefile b/makefile
index f3112c4..0de7db3 100644
--- a/makefile
+++ b/makefile
@@ -19,7 +19,7 @@ INCLUDE_PATHS = \
 	-Idsymbol/src -Icontainers/src
 VERSIONS =
 DEBUG_VERSIONS = -version=std_parser_verbose
-DMD_FLAGS = -w -O -inline -J. -od${OBJ_DIR}
+DMD_FLAGS = -w -O -inline -J. -od${OBJ_DIR} -version=StdLoggerDisableWarning
 DMD_TEST_FLAGS = -w -g -unittest -J.
 
 all: dmdbuild
diff --git a/src/analysis/mismatched_args.d b/src/analysis/mismatched_args.d
index 332b431..f005df6 100644
--- a/src/analysis/mismatched_args.d
+++ b/src/analysis/mismatched_args.d
@@ -5,15 +5,16 @@ import dsymbol.scope_;
 import dsymbol.symbol;
 import std.d.ast;
 import std.d.lexer : tok;
+import dsymbol.builtin.names;
 
 /// Checks for mismatched argument and parameter names
 final class MismatchedArgumentCheck : BaseAnalyzer
 {
 	///
-    this(string fileName, const Scope* sc)
-    {
-        super(fileName, sc);
-    }
+	this(string fileName, const Scope* sc)
+	{
+		super(fileName, sc);
+	}
 
 	override void visit(const FunctionCallExpression fce)
 	{
@@ -30,10 +31,11 @@ final class MismatchedArgumentCheck : BaseAnalyzer
 		auto identVisitor = scoped!IdentVisitor;
 		identVisitor.visit(fce.unaryExpression);
 
-		const(DSymbol)* sym = resolveSymbol(sc, identVisitor.names);
+		const(DSymbol)* sym = resolveSymbol(sc,
+			identVisitor.names.length > 0 ? identVisitor.names : [CONSTRUCTOR_SYMBOL_NAME]);
 		const istring[] params = sym is null ? [] : sym.opSlice().map!(a => cast() a.name).array();
 		const ArgMismatch[] mismatches = compareArgsToParams(params, args);
-		foreach(size_t i, ref const mm; mismatches)
+		foreach (size_t i, ref const mm; mismatches)
 			addErrorMessage(argVisitor.lines[i], argVisitor.columns[i], KEY,
 				createWarningFromMismatch(mm));
 	}
@@ -90,8 +92,8 @@ final class ArgVisitor : ASTVisitor
 		}
 	}
 
-    override void visit(const UnaryExpression unary)
-    {
+	override void visit(const UnaryExpression unary)
+	{
 		import dsymbol.string_interning : internString;
 
 		if (unary.primaryExpression is null)
@@ -104,18 +106,18 @@ final class ArgVisitor : ASTVisitor
 		lines ~= t.line;
 		columns ~= t.column;
 		args ~= internString(t.text);
-    }
+	}
 
 	alias visit = ASTVisitor.visit;
 
 	size_t[] lines;
 	size_t[] columns;
-    istring[] args;
+	istring[] args;
 }
 
 const(DSymbol)* resolveSymbol(const Scope* sc, const istring[] symbolChain)
 {
-	import std.array:empty;
+	import std.array : empty;
 
 	const(DSymbol)*[] s = sc.getSymbolsByName(symbolChain[0]);
 	if (s.empty)
@@ -124,7 +126,8 @@ const(DSymbol)* resolveSymbol(const Scope* sc, const istring[] symbolChain)
 	const(DSymbol)* sym = s[0];
 	foreach (i; 1 .. symbolChain.length)
 	{
-		if (sym.kind == CompletionKind.variableName || sym.kind == CompletionKind.memberVariableName
+		if (sym.kind == CompletionKind.variableName
+				|| sym.kind == CompletionKind.memberVariableName
 				|| sym.kind == CompletionKind.functionName)
 			sym = sym.type;
 		if (sym is null)
@@ -139,62 +142,62 @@ const(DSymbol)* resolveSymbol(const Scope* sc, const istring[] symbolChain)
 
 struct ArgMismatch
 {
-    size_t argIndex;
-    size_t paramIndex;
+	size_t argIndex;
+	size_t paramIndex;
 	string name;
 }
 
 const(ArgMismatch[]) compareArgsToParams(const istring[] params, const istring[] args) pure
 {
-	if(args.length != params.length)
+	if (args.length != params.length)
 		return [];
-    ArgMismatch[] retVal;
-    foreach (i, arg; args)
-    {
-        if (arg is null || arg == params[i])
-            continue;
-        foreach (j, param; params)
-            if (param == arg)
+	ArgMismatch[] retVal;
+	foreach (i, arg; args)
+	{
+		if (arg is null || arg == params[i])
+			continue;
+		foreach (j, param; params)
+			if (param == arg)
 				retVal ~= ArgMismatch(i, j, arg);
-    }
-    return retVal;
+	}
+	return retVal;
 }
 
 string createWarningFromMismatch(const ArgMismatch mismatch) pure
 {
-    import std.format : format;
+	import std.format : format;
 
-    return "Argument %d is named '%s', but this is the name of parameter %d"
-        .format(mismatch.argIndex + 1, mismatch.name, mismatch.paramIndex + 1);
+	return "Argument %d is named '%s', but this is the name of parameter %d".format(
+		mismatch.argIndex + 1, mismatch.name, mismatch.paramIndex + 1);
 }
 
 unittest
 {
-    {
-        string[] args = ["a", "b", "c"];
-        string[] params = ["a", "b", "c"];
-        immutable res = compareArgsToParams(params, args);
-        assert(res == []);
-    }
+	{
+		string[] args = ["a", "b", "c"];
+		string[] params = ["a", "b", "c"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == []);
+	}
 
-    {
-        string[] args = ["a", "c", "b"];
-        string[] params = ["a", "b", "c"];
-        immutable res = compareArgsToParams(params, args);
-        assert(res == [ArgMismatch(1, 2), ArgMismatch(2, 1)]);
-    }
+	{
+		string[] args = ["a", "c", "b"];
+		string[] params = ["a", "b", "c"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == [ArgMismatch(1, 2), ArgMismatch(2, 1)]);
+	}
 
-    {
-        string[] args = ["a", "c", "b"];
-        string[] params = ["alpha", "bravo", "c"];
-        immutable res = compareArgsToParams(params, args);
-        assert(res == [ArgMismatch(1, 2)]);
-    }
+	{
+		string[] args = ["a", "c", "b"];
+		string[] params = ["alpha", "bravo", "c"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == [ArgMismatch(1, 2)]);
+	}
 
-    {
-        string[] args = ["a", "b"];
-        string[] params = [null, "b"];
-        immutable res = compareArgsToParams(params, args);
-        assert(res == []);
-    }
+	{
+		string[] args = ["a", "b"];
+		string[] params = [null, "b"];
+		immutable res = compareArgsToParams(params, args);
+		assert(res == []);
+	}
 }

From 27a423e3fa547c739aecffc251b0832e6b8141ec Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 05:22:03 -0700
Subject: [PATCH 13/25] Fix #269

---
 libdparse                       |  2 +-
 src/analysis/comma_expression.d | 16 +++++++++++++++-
 src/analysis/ifelsesame.d       |  2 +-
 src/analysis/unmodified.d       |  2 +-
 src/analysis/unused.d           |  6 +++---
 src/astprinter.d                |  8 ++++----
 6 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/libdparse b/libdparse
index a059356..b579192 160000
--- a/libdparse
+++ b/libdparse
@@ -1 +1 @@
-Subproject commit a059356c94e949625417ea98c9c1c59186fa285f
+Subproject commit b5791923695c755aae9cf313555fd20c5b0993d9
diff --git a/src/analysis/comma_expression.d b/src/analysis/comma_expression.d
index d628ec7..5ce999d 100644
--- a/src/analysis/comma_expression.d
+++ b/src/analysis/comma_expression.d
@@ -24,7 +24,7 @@ class CommaExpressionCheck : BaseAnalyzer
 
 	override void visit(const Expression ex)
 	{
-		if (ex.items.length > 1)
+		if (ex.items.length > 1 && interest > 0)
 		{
 			addErrorMessage(ex.line, ex.column, KEY,
 				"Avoid using the comma expression.");
@@ -32,5 +32,19 @@ class CommaExpressionCheck : BaseAnalyzer
 		ex.accept(this);
 	}
 
+	override void visit(const AssignExpression ex)
+	{
+		++interest;
+		ex.accept(this);
+		--interest;
+	}
+
+	invariant
+	{
+		assert(interest >= 0);
+	}
+
+	int interest;
+
 	private enum KEY = "dscanner.suspicious.comma_expression";
 }
diff --git a/src/analysis/ifelsesame.d b/src/analysis/ifelsesame.d
index 8d11e95..2940133 100644
--- a/src/analysis/ifelsesame.d
+++ b/src/analysis/ifelsesame.d
@@ -40,7 +40,7 @@ class IfElseSameCheck : BaseAnalyzer
 
 	override void visit(const AssignExpression assignExpression)
 	{
-		const AssignExpression e = cast(const AssignExpression) assignExpression.assignExpression;
+		auto e = cast(const AssignExpression) (cast(const Expression) assignExpression.expression).items[$ - 1];
 		if (e !is null && assignExpression.operator == tok!"="
 			&& e.ternaryExpression == assignExpression.ternaryExpression)
 		{
diff --git a/src/analysis/unmodified.d b/src/analysis/unmodified.d
index f53bcfc..7a06cc5 100644
--- a/src/analysis/unmodified.d
+++ b/src/analysis/unmodified.d
@@ -93,7 +93,7 @@ class UnmodifiedFinder:BaseAnalyzer
 			assignExpression.ternaryExpression.accept(this);
 			guaranteeUse--;
 			interest--;
-			assignExpression.assignExpression.accept(this);
+			assignExpression.expression.accept(this);
 		}
 		else
 			assignExpression.accept(this);
diff --git a/src/analysis/unused.d b/src/analysis/unused.d
index 654e75d..51d164d 100644
--- a/src/analysis/unused.d
+++ b/src/analysis/unused.d
@@ -154,17 +154,17 @@ class UnusedVariableCheck : BaseAnalyzer
 	override void visit(const AssignExpression assignExp)
 	{
 		assignExp.ternaryExpression.accept(this);
-		if (assignExp.assignExpression !is null)
+		if (assignExp.expression !is null)
 		{
 			interestDepth++;
-			assignExp.assignExpression.accept(this);
+			assignExp.expression.accept(this);
 			interestDepth--;
 		}
 	}
 
 	override void visit(const TemplateDeclaration templateDeclaration)
 	{
-		auto inAgg = inAggregateScope;
+		immutable inAgg = inAggregateScope;
 		inAggregateScope = true;
 		templateDeclaration.accept(this);
 		inAggregateScope = inAgg;
diff --git a/src/astprinter.d b/src/astprinter.d
index 94dfa78..c6d53ee 100644
--- a/src/astprinter.d
+++ b/src/astprinter.d
@@ -113,13 +113,13 @@ class XMLPrinter : ASTVisitor
 
     override void visit(const AssignExpression assignExpression)
     {
-        if (assignExpression.assignExpression is null)
-            output.writeln("<assignExpression>");
+        if (assignExpression.expression is null)
+            output.writeln("<expression>");
         else
-            output.writeln("<assignExpression operator=\"",
+            output.writeln("<expression operator=\"",
                 xmlAttributeEscape(str(assignExpression.operator)), "\">");
         assignExpression.accept(this);
-        output.writeln("</assignExpression>");
+        output.writeln("</expression>");
     }
 
     override void visit(const AtAttribute atAttribute)

From dffed0ab24c1d636a996bf95288203a84cc3f11f Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 11:47:28 -0700
Subject: [PATCH 14/25] Fix #238

---
 src/analysis/label_var_same_name_check.d | 69 +++++++++++++++++++-----
 1 file changed, 56 insertions(+), 13 deletions(-)

diff --git a/src/analysis/label_var_same_name_check.d b/src/analysis/label_var_same_name_check.d
index ea2741f..8865c4a 100644
--- a/src/analysis/label_var_same_name_check.d
+++ b/src/analysis/label_var_same_name_check.d
@@ -44,35 +44,52 @@ class LabelVarNameCheck : BaseAnalyzer
 	override void visit(const VariableDeclaration var)
 	{
 		foreach (dec; var.declarators)
-			duplicateCheck(dec.name, false);
+			duplicateCheck(dec.name, false, conditionalDepth > 0);
 	}
 
 	override void visit(const LabeledStatement labeledStatement)
 	{
-		duplicateCheck(labeledStatement.identifier, true);
+		duplicateCheck(labeledStatement.identifier, true, conditionalDepth > 0);
 		if (labeledStatement.declarationOrStatement !is null)
 			labeledStatement.declarationOrStatement.accept(this);
 	}
 
+	override void visit(const ConditionalDeclaration condition)
+	{
+		if (condition.falseDeclaration)
+			++conditionalDepth;
+		condition.accept(this);
+		if (condition.falseDeclaration)
+			--conditionalDepth;
+	}
+
 	alias visit = BaseAnalyzer.visit;
 
 private:
 
 	Thing[string][] stack;
 
-	void duplicateCheck(const Token name, bool fromLabel)
+	void duplicateCheck(const Token name, bool fromLabel, bool isConditional)
 	{
 		import std.conv : to;
-		const(Thing)* thing = name.text in currentScope;
-		if (thing is null)
-			currentScope[name.text] = Thing(name.text, name.line, name.column, false);
-		else
+		import std.range : retro;
+
+		size_t i = 0;
+		foreach (s; retro(stack))
 		{
-			immutable thisKind = fromLabel ? "Label" : "Variable";
-			immutable otherKind = thing.isVar ? "variable" : "label";
-			addErrorMessage(name.line, name.column, "dscanner.suspicious.label_var_same_name",
-				thisKind ~ " \"" ~ name.text ~ "\" has the same name as a "
-				~ otherKind ~ " defined on line " ~ to!string(thing.line) ~ ".");
+			const(Thing)* thing = name.text in s;
+			if (thing is null)
+				currentScope[name.text] = Thing(name.text, name.line, name.column,
+					!fromLabel/+, isConditional+/);
+			else if (i != 0 || !isConditional)
+			{
+				immutable thisKind = fromLabel ? "Label" : "Variable";
+				immutable otherKind = thing.isVar ? "variable" : "label";
+				addErrorMessage(name.line, name.column, "dscanner.suspicious.label_var_same_name",
+					thisKind ~ " \"" ~ name.text ~ "\" has the same name as a "
+					~ otherKind ~ " defined on line " ~ to!string(thing.line) ~ ".");
+			}
+			++i;
 		}
 	}
 
@@ -82,6 +99,7 @@ private:
 		size_t line;
 		size_t column;
 		bool isVar;
+		//bool isConditional;
 	}
 
 	ref currentScope() @property
@@ -98,6 +116,8 @@ private:
 	{
 		stack.length--;
 	}
+
+	int conditionalDepth;
 }
 
 unittest
@@ -114,6 +134,29 @@ blah:
 	int blah; // [warn]: Variable "blah" has the same name as a label defined on line 4.
 }
 int blah;
-	}c, sac);
+unittest
+{
+	static if (stuff)
+		int a;
+	int a; // [warn]: Variable "a" has the same name as a variable defined on line 11.
+}
+
+unittest
+{
+	static if (stuff)
+		int a = 10;
+	else
+		int a = 20;
+}
+
+unittest
+{
+	static if (stuff)
+		int a = 10;
+	else
+		int a = 20;
+	int a; // [warn]: Variable "a" has the same name as a variable defined on line 28.
+}
+}c, sac);
 	stderr.writeln("Unittest for LabelVarNameCheck passed.");
 }

From 887245a493dd7c5c3c62f3253ad254f84bef55f8 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 11:48:03 -0700
Subject: [PATCH 15/25] Add test target and Travis config file

---
 .travis.yml | 5 ++++-
 makefile    | 4 +++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index cf18889..d3ce18a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,2 +1,5 @@
-language: d
 sudo: false
+language: d
+script:
+    - git submodule update --init --recursive
+    - make test
diff --git a/makefile b/makefile
index 0de7db3..c5cecc1 100644
--- a/makefile
+++ b/makefile
@@ -46,7 +46,9 @@ ldcbuild: githash
 	${LDC} -O5 -release -oq -of=bin/dscanner ${VERSIONS} ${INCLUDE_PATHS} ${SRC} -J.
 
 test:
-	@./test.sh
+	${DC} -w -g -J. -unittest ${INCLUDE_PATHS} ${SRC} -ofbin/dscanner-unittest -version=StdLoggerDisableWarning
+	./bin/dscanner-unittest
+	rm -f bin/dscanner-unittest
 
 clean:
 	rm -rf dsc

From 280c8a53f2673c5bca7048ddae1d5d1c05dcd206 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 11:48:24 -0700
Subject: [PATCH 16/25] Fix failing unit test

---
 src/analysis/mismatched_args.d | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/src/analysis/mismatched_args.d b/src/analysis/mismatched_args.d
index f005df6..bb88d60 100644
--- a/src/analysis/mismatched_args.d
+++ b/src/analysis/mismatched_args.d
@@ -147,8 +147,10 @@ struct ArgMismatch
 	string name;
 }
 
-const(ArgMismatch[]) compareArgsToParams(const istring[] params, const istring[] args) pure
+immutable(ArgMismatch[]) compareArgsToParams(const istring[] params, const istring[] args) pure
 {
+	import std.exception : assumeUnique;
+
 	if (args.length != params.length)
 		return [];
 	ArgMismatch[] retVal;
@@ -160,7 +162,7 @@ const(ArgMismatch[]) compareArgsToParams(const istring[] params, const istring[]
 			if (param == arg)
 				retVal ~= ArgMismatch(i, j, arg);
 	}
-	return retVal;
+	return assumeUnique(retVal);
 }
 
 string createWarningFromMismatch(const ArgMismatch mismatch) pure
@@ -173,30 +175,35 @@ string createWarningFromMismatch(const ArgMismatch mismatch) pure
 
 unittest
 {
+	import dsymbol.string_interning : internString;
+	import std.algorithm.iteration : map;
+	import std.array : array;
+	import std.conv : to;
+
 	{
-		string[] args = ["a", "b", "c"];
-		string[] params = ["a", "b", "c"];
+		istring[] args = ["a", "b", "c"].map!internString().array();
+		istring[] params = ["a", "b", "c"].map!internString().array();
 		immutable res = compareArgsToParams(params, args);
 		assert(res == []);
 	}
 
 	{
-		string[] args = ["a", "c", "b"];
-		string[] params = ["a", "b", "c"];
+		istring[] args = ["a", "c", "b"].map!internString().array();
+		istring[] params = ["a", "b", "c"].map!internString().array();
 		immutable res = compareArgsToParams(params, args);
-		assert(res == [ArgMismatch(1, 2), ArgMismatch(2, 1)]);
+		assert(res == [ArgMismatch(1, 2, "c"), ArgMismatch(2, 1, "b")], to!string(res));
 	}
 
 	{
-		string[] args = ["a", "c", "b"];
-		string[] params = ["alpha", "bravo", "c"];
+		istring[] args = ["a", "c", "b"].map!internString().array();
+		istring[] params = ["alpha", "bravo", "c"].map!internString().array();
 		immutable res = compareArgsToParams(params, args);
-		assert(res == [ArgMismatch(1, 2)]);
+		assert(res == [ArgMismatch(1, 2, "c")]);
 	}
 
 	{
-		string[] args = ["a", "b"];
-		string[] params = [null, "b"];
+		istring[] args = ["a", "b"].map!internString().array();
+		istring[] params = [null, "b"].map!internString().array();
 		immutable res = compareArgsToParams(params, args);
 		assert(res == []);
 	}

From 80d358d8ca118922cbad49baa28f9f7fe1d93c3a Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 11:51:49 -0700
Subject: [PATCH 17/25] Add CI status link and made naming more consistent

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index d5be4ea..f17a051 100644
--- a/README.md
+++ b/README.md
@@ -1,11 +1,11 @@
-# Overview
-DScanner is a tool for analyzing D source code
+# D-Scanner [![CI status](https://travis-ci.org/Hackerpilot/Dscanner.svg?branch=master)](https://travis-ci.org/Hackerpilot/Dscanner/)
+D-Scanner is a tool for analyzing D source code
 
 ### Building and installing
 First make sure that you have all the source code. Run ```git submodule update --init --recursive```
 after cloning the project.
 
-To build DScanner, run ```make``` (or the build.bat file on Windows).
+To build D-Scanner, run ```make``` (or the build.bat file on Windows).
 The build time can be rather long with the -inline flag on front-end versions
 older than 2.066, so you may wish to remove it from the build script. The
 makefile has "ldc" and "gdc" targets if you'd prefer to compile with one of these

From 2abf50d18e47bfe069844cd53cc93c32008accea Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 18 Sep 2015 11:53:50 -0700
Subject: [PATCH 18/25] Add githash target to testing dependencies to fix build

---
 makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/makefile b/makefile
index c5cecc1..eb1cf60 100644
--- a/makefile
+++ b/makefile
@@ -45,7 +45,7 @@ ldcbuild: githash
 	mkdir -p bin
 	${LDC} -O5 -release -oq -of=bin/dscanner ${VERSIONS} ${INCLUDE_PATHS} ${SRC} -J.
 
-test:
+test: githash
 	${DC} -w -g -J. -unittest ${INCLUDE_PATHS} ${SRC} -ofbin/dscanner-unittest -version=StdLoggerDisableWarning
 	./bin/dscanner-unittest
 	rm -f bin/dscanner-unittest

From f25602a9c5c55e3d4a77733d52f0acb30a1c2fd4 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Mon, 21 Sep 2015 15:50:18 -0700
Subject: [PATCH 19/25] Update dsymbol to fix bug in the mismatched arg checker

---
 dsymbol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dsymbol b/dsymbol
index e83afca..fd3a0df 160000
--- a/dsymbol
+++ b/dsymbol
@@ -1 +1 @@
-Subproject commit e83afca7cf2cac48084ba294926d4dd24945dc1a
+Subproject commit fd3a0dff1b6759e730119ef10c8eff04d4adf585

From ec14694db19cb5f8e143ac58474bd9b0ad9931d2 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 25 Sep 2015 14:40:53 -0700
Subject: [PATCH 20/25] Fix duplicated output for unary expressions

---
 src/astprinter.d | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/astprinter.d b/src/astprinter.d
index c6d53ee..5fa93f0 100644
--- a/src/astprinter.d
+++ b/src/astprinter.d
@@ -911,15 +911,18 @@ class XMLPrinter : ASTVisitor
                 "</prefix>");
             unaryExpression.unaryExpression.accept(this);
         }
-        if (unaryExpression.suffix != tok!"")
-        {
-            assert(unaryExpression.suffix.text == "");
-            unaryExpression.unaryExpression.accept(this);
-            output.writeln("<suffix>", str(unaryExpression.suffix.type),
-                "</suffix>");
-        }
         else
-            unaryExpression.accept(this);
+        {
+            if (unaryExpression.suffix != tok!"")
+            {
+                assert(unaryExpression.suffix.text == "");
+                unaryExpression.unaryExpression.accept(this);
+                output.writeln("<suffix>", str(unaryExpression.suffix.type),
+                    "</suffix>");
+            }
+            else
+                unaryExpression.accept(this);
+        }
         output.writeln("</unaryExpression>");
     }
 

From 2cf8ebe95610cee79e129f0b5fb5de85f431f774 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 25 Sep 2015 15:40:17 -0700
Subject: [PATCH 21/25] Fix bug in mismatched arg name checker

---
 dsymbol                        | 2 +-
 src/analysis/mismatched_args.d | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/dsymbol b/dsymbol
index fd3a0df..1ac138f 160000
--- a/dsymbol
+++ b/dsymbol
@@ -1 +1 @@
-Subproject commit fd3a0dff1b6759e730119ef10c8eff04d4adf585
+Subproject commit 1ac138f58fe24d59519a5a92758701e9007d0ad6
diff --git a/src/analysis/mismatched_args.d b/src/analysis/mismatched_args.d
index bb88d60..965d25c 100644
--- a/src/analysis/mismatched_args.d
+++ b/src/analysis/mismatched_args.d
@@ -33,7 +33,9 @@ final class MismatchedArgumentCheck : BaseAnalyzer
 
 		const(DSymbol)* sym = resolveSymbol(sc,
 			identVisitor.names.length > 0 ? identVisitor.names : [CONSTRUCTOR_SYMBOL_NAME]);
-		const istring[] params = sym is null ? [] : sym.opSlice().map!(a => cast() a.name).array();
+		// The cast is a hack because .array() confuses the compiler's overload
+		// resolution code.
+		const(istring)[] params = sym is null ? [] : sym.argNames[].map!(a => cast() a).array();
 		const ArgMismatch[] mismatches = compareArgsToParams(params, args);
 		foreach (size_t i, ref const mm; mismatches)
 			addErrorMessage(argVisitor.lines[i], argVisitor.columns[i], KEY,

From f99d4ae954fb3f6e0987d16ddb74d937ff951f9b Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 25 Sep 2015 17:54:45 -0700
Subject: [PATCH 22/25] Fix #226

---
 src/analysis/unmodified.d | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/analysis/unmodified.d b/src/analysis/unmodified.d
index 7a06cc5..5743aa4 100644
--- a/src/analysis/unmodified.d
+++ b/src/analysis/unmodified.d
@@ -93,7 +93,12 @@ class UnmodifiedFinder:BaseAnalyzer
 			assignExpression.ternaryExpression.accept(this);
 			guaranteeUse--;
 			interest--;
+
+			if (assignExpression.operator == tok!"~=")
+				interest++;
 			assignExpression.expression.accept(this);
+			if (assignExpression.operator == tok!"~=")
+				interest--;
 		}
 		else
 			assignExpression.accept(this);

From b91b10afa8589b3ff8019620611139e763da13a0 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 9 Oct 2015 14:53:44 -0700
Subject: [PATCH 23/25] Update dsymbol

---
 dsymbol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dsymbol b/dsymbol
index 1ac138f..20f7fac 160000
--- a/dsymbol
+++ b/dsymbol
@@ -1 +1 @@
-Subproject commit 1ac138f58fe24d59519a5a92758701e9007d0ad6
+Subproject commit 20f7facf804c889d4d31c579ddfbf174d0fccbe5

From f50c4bb43f36d516ef4a453def57fefa7d706330 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 9 Oct 2015 14:53:52 -0700
Subject: [PATCH 24/25] Update inifiled

---
 inifiled | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/inifiled b/inifiled
index 72393ec..ebe9c5d 160000
--- a/inifiled
+++ b/inifiled
@@ -1 +1 @@
-Subproject commit 72393ec2e0711630ad93a15c66b0ea567b5b44df
+Subproject commit ebe9c5d0a3c1c8cb5a7df13e165e6b9bdf78866f

From e5279e94f76b92d0a5df613f883eba9c95e52b00 Mon Sep 17 00:00:00 2001
From: Hackerpilot <briancschott@gmail.com>
Date: Fri, 9 Oct 2015 14:54:28 -0700
Subject: [PATCH 25/25] Fix #286

---
 src/analysis/unmodified.d | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/analysis/unmodified.d b/src/analysis/unmodified.d
index 5743aa4..6839c0a 100644
--- a/src/analysis/unmodified.d
+++ b/src/analysis/unmodified.d
@@ -174,6 +174,13 @@ class UnmodifiedFinder:BaseAnalyzer
 		// issue #270: Ignore unmodified variables inside of `typeof` expressions
 	}
 
+	override void visit(const AsmStatement a)
+	{
+		inAsm = true;
+		a.accept(this);
+		inAsm = false;
+	}
+
 private:
 
 	template PartsMightModify(T)
@@ -193,7 +200,7 @@ private:
 		if (guaranteeUse == 0)
 		{
 			auto r = tree[index].equalRange(&vi);
-			if (!r.empty && r.front.isValueType)
+			if (!r.empty && r.front.isValueType && !inAsm)
 				return;
 		}
 		while (true)
@@ -289,6 +296,8 @@ private:
 
 	int isImmutable;
 
+	bool inAsm;
+
 	RedBlackTree!(VariableInfo*, "a.name < b.name")[] tree;
 }