upgrade libdparse

should first check if the range `beforeTokens` is empty.

.github/workflows/ci.yml

@@ -75,14 +75,14 @@ jobs:
       - name: Linux Tests
         if: contains(matrix.os, 'ubuntu')
         run: |
-          ./run_tests.sh
+          ./run_tests.sh --extra
         working-directory: tests
         shell: bash
 
       - name: Windows and MacOS Tests
         if: contains(matrix.os, 'windows') || contains(matrix.os, 'macos')
         run: |
-          ./run_tests.sh
+          ./run_tests.sh --extra
         working-directory: tests
         shell: bash
         continue-on-error: true

.github/workflows/pr_info_intro.yml

@@ -0,0 +1,24 @@
+name: PR Info (pre-comment)
+
+on:
+  # NOTE: high probability for security vulnerabilities if doing ANYTHING in
+  # this file other than commenting something!
+  pull_request_target:
+    branches:
+      - master
+
+jobs:
+  intro_comment:
+    name: Make intro comment
+    runs-on: ubuntu-20.04
+    steps:
+    - name: 'Prepare sticky comment'
+      # commit of v2.5.0
+      # same one used again at the bottom of the file to update the comment.
+      uses: marocchino/sticky-pull-request-comment@3d60a5b2dae89d44e0c6ddc69dd7536aec2071cd
+      with:
+        message: |
+          Thanks for your Pull Request and making D better!
+
+          This comment will automatically be updated to summarize some statistics in a few minutes.
+        only_create: true

.github/workflows/pr_info_post.yml

@@ -0,0 +1,49 @@
+name: PR Info (comment)
+
+on:
+  workflow_run:
+    workflows: ["PR Info"]
+    types:
+      - completed
+
+jobs:
+  comment:
+    name: PR Info
+    runs-on: ubuntu-20.04
+    if: >
+      github.event.workflow_run.event == 'pull_request' &&
+      github.event.workflow_run.conclusion == 'success'
+    steps:
+    # from https://securitylab.github.com/research/github-actions-preventing-pwn-requests/
+    - name: 'Download artifact'
+      uses: actions/github-script@v3.1.0
+      with:
+        script: |
+          var artifacts = await github.actions.listWorkflowRunArtifacts({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            run_id: ${{github.event.workflow_run.id }},
+          });
+          var matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+            return artifact.name == "pr"
+          })[0];
+          var download = await github.actions.downloadArtifact({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            artifact_id: matchArtifact.id,
+            archive_format: 'zip',
+          });
+          var fs = require('fs');
+          fs.writeFileSync('${{github.workspace}}/pr.zip', Buffer.from(download.data));
+    - run: unzip pr.zip
+
+    - name: Set variable
+      run: |
+        PR_ID=$(cat ./NR)
+        echo "PR_ID=$PR_ID" >> $GITHUB_ENV
+
+    - name: Update GitHub comment
+      uses: marocchino/sticky-pull-request-comment@3d60a5b2dae89d44e0c6ddc69dd7536aec2071cd
+      with:
+        path: ./comment.txt
+        number: ${{ env.PR_ID }}

.github/workflows/pr_info_untrusted.yml

@@ -0,0 +1,67 @@
+name: PR Info
+
+# This workflow builds the whole project once and:
+# - comments build deprecations/warnings (highlighting new ones since last tested PR)
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  pr_info:
+    name: PR Info
+    runs-on: ubuntu-latest
+    steps:
+    # we first create a comment thanking the user in pr_info_intro.yml
+    # (separate step due to needing GITHUB_TOKEN access)
+
+    # Compiler to test with
+    - name: Prepare compiler
+      uses: dlang-community/setup-dlang@v1
+      with:
+        compiler: dmd-latest
+
+    - name: Prepare compiler
+      uses: dlang-community/setup-dlang@v1
+      with:
+        compiler: ldc-latest
+
+    - name: Checkout
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+
+    - name: Checkout old stuff, with new comment script
+      run: |
+        git checkout ${{ github.base_ref }}
+        git checkout ${{ github.sha }} -- ./ci/summary_comment.sh ./ci/summary_comment_diff.sh
+
+    # first dump old info
+
+    - name: Check pre-PR status
+      run: ./ci/summary_comment.sh | tee ../OLD_OUTPUT.txt
+
+    - name: Checkout PR target
+      run: |
+        git checkout ${{ github.sha }}
+        git clean -fd
+        git reset --hard
+
+    - name: Evaluate PR
+      run: ./ci/summary_comment.sh | tee ../NEW_OUTPUT.txt
+
+    - name: Generate comment
+      run: ./ci/summary_comment_diff.sh ../OLD_OUTPUT.txt ../NEW_OUTPUT.txt | tee comment.txt
+
+    - name: Prepare comment for upload
+      run: |
+        mkdir -p ./pr
+        mv comment.txt pr
+        echo ${{ github.event.number }} > ./pr/NR
+
+    - name: upload comment to high-trust action making the comment
+      uses: actions/upload-artifact@v4
+      with:
+        name: pr
+        path: pr/

.gitignore

@@ -16,6 +16,10 @@ perf.data.old
 
 # Valgrind reports
 callgrind.*
+massif.*
+
+# D profiling tools
+profilegc.log
 
 # GDB temp files
 .gdb_history

README.md

@@ -314,6 +314,19 @@ Otherwise the client outputs _00000_ so that the length of the answer is guarant
     45
     133
 
+## Inlay Hints
+
+Build a list of extra annoations for your IDE to display.
+You must submit the content of the current file displayed in your editor.
+
+    dcd-client --inlayHints
+
+This is a W.I.P., currently it only provide annoatations about aliases for your variables,
+more is planned.
+
+#### Example output
+
+    l   ->MyAlias->MyType   42
 
 # Server
 

ci/request_time_stats.d

@@ -0,0 +1,109 @@
+import core.time;
+import std.algorithm;
+import std.conv;
+import std.format;
+import std.stdio;
+import std.string;
+
+void main()
+{
+	long[] shortRequests, longRequests;
+
+	foreach (line; stdin.byLine)
+	{
+		auto index = line.countUntil("Request processed in ");
+		if (index == -1)
+		{
+			stderr.writeln("Warning: skipping unknown line for stats: ", line);
+			continue;
+		}
+		index += "Request processed in ".length;
+		auto dur = line[index .. $].parseDuration;
+		if (dur != Duration.init)
+		{
+			if (dur >= 10.msecs)
+				longRequests ~= dur.total!"hnsecs";
+			else
+				shortRequests ~= dur.total!"hnsecs";
+		}
+	}
+
+	if (shortRequests.length > 0)
+	{
+		writeln("STAT:short requests: (", shortRequests.length, "x)");
+		summarize(shortRequests);
+	}
+	writeln("STAT:");
+	if (longRequests.length > 0)
+	{
+		writeln("STAT:long requests over 10ms: (", longRequests.length, "x)");
+		summarize(longRequests);
+	}
+}
+
+void summarize(long[] hnsecs)
+{
+	hnsecs.sort!"a<b";
+
+	auto minRequest = hnsecs[0];
+	auto maxRequest = hnsecs[$ - 1];
+	auto medianRequest = hnsecs[$ / 2];
+	auto p10Request = hnsecs[$ * 10 / 100];
+	auto p90Request = hnsecs[$ * 90 / 100];
+
+	writeln("STAT:    min request time = ", minRequest.formatHnsecs);
+	writeln("STAT:    10th percentile  = ", p10Request.formatHnsecs);
+	writeln("STAT:    median time      = ", medianRequest.formatHnsecs);
+	writeln("STAT:    90th percentile  = ", p90Request.formatHnsecs);
+	writeln("STAT:    max request time = ", maxRequest.formatHnsecs);
+}
+
+string formatHnsecs(T)(T hnsecs)
+{
+	return format!"%9.3fms"(cast(double)hnsecs / cast(double)1.msecs.total!"hnsecs");
+}
+
+Duration parseDuration(scope const(char)[] dur)
+{
+	auto origDur = dur;
+	scope (failure)
+		stderr.writeln("Failed to parse ", origDur);
+	Duration ret;
+	while (dur.length)
+	{
+		dur = dur.stripLeft;
+		if (dur.startsWith(","))
+			dur = dur[1 .. $].stripLeft;
+		if (dur.startsWith("and"))
+			dur = dur[3 .. $].stripLeft;
+		auto num = dur.parse!int;
+		dur = dur.stripLeft;
+		switch (dur.startsWith(num == 1 ? "minute" : "minutes", num == 1 ? "sec" : "secs", "ms", "μs", num == 1 ? "hnsec" : "hnsecs"))
+		{
+		case 1:
+			dur = dur[(num == 1 ? "minute" : "minutes").length .. $];
+			ret += num.minutes;
+			break;
+		case 2:
+			dur = dur[(num == 1 ? "sec" : "secs").length .. $];
+			ret += num.seconds;
+			break;
+		case 3:
+			dur = dur["ms".length .. $];
+			ret += num.msecs;
+			break;
+		case 4:
+			dur = dur["μs".length .. $];
+			ret += num.usecs;
+			break;
+		case 5:
+			dur = dur[(num == 1 ? "hnsec" : "hnsecs").length .. $];
+			ret += num.hnsecs;
+			break;
+		default:
+			stderr.writeln("Warning: unimplemented duration parsing for ", origDur, " (at ", dur, ")");
+			return Duration.init;
+		}
+	}
+	return ret;
+}

ci/summary_comment.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+set -u
+
+# Output from this script is piped to a file by CI, being run from before a
+# change has been made and after a change has been made. Then both outputs are
+# compared using summary_comment_diff.sh
+
+# cd to git folder, just in case this is manually run:
+ROOT_DIR="$( cd "$(dirname "${BASH_SOURCE[0]}")/../" && pwd )"
+cd ${ROOT_DIR}
+
+dub --version
+ldc2 --version
+
+# fetch missing packages before timing
+dub upgrade --missing-only
+
+rm -rf .dub bin
+
+start=`date +%s`
+dub build --build=release --config=client --compiler=ldc2 --force 2>&1 || echo "DCD BUILD FAILED"
+dub build --build=release --config=server --compiler=ldc2 --force 2>&1 || echo "DCD BUILD FAILED"
+end=`date +%s`
+build_time=$( echo "$end - $start" | bc -l )
+
+strip bin/dcd-server
+strip bin/dcd-client
+
+echo "STAT:statistics (-before, +after)"
+echo "STAT:client size=$(wc -c bin/dcd-client)"
+echo "STAT:server size=$(wc -c bin/dcd-server)"
+echo "STAT:rough build time=${build_time}s"
+echo "STAT:"
+
+cd tests
+./run_tests.sh --time-server --extra
+
+echo "STAT:DCD run_tests.sh $(grep -F 'Elapsed (wall clock) time' stderr.txt)"
+echo "STAT:DCD run_tests.sh $(grep -F 'Maximum resident set size (kbytes)' stderr.txt)"
+
+echo "STAT:"
+grep -E 'Request processed in .*' stderr.txt | rdmd ../ci/request_time_stats.d
+echo "STAT:"
+
+# now rebuild server with -profile=gc
+cd ..
+rm -rf .dub bin/dcd-server
+dub build --build=profile-gc --config=server --compiler=dmd 2>&1 || echo "DCD BUILD FAILED"
+
+cd tests
+./run_tests.sh --extra
+
+echo "STAT:top 5 GC sources in server:"
+if [ ! -f "profilegc.log" ]; then
+	echo 'Missing profilegc.log file!'
+	echo 'Tail for stderr.txt:'
+	tail -n50 stderr.txt
+fi
+head -n6 profilegc.log | sed 's/^/STAT:/g'

ci/summary_comment_diff.sh

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+
+set -u
+
+EMPTY=1
+
+ADDED=$(diff --new-line-format='%L' --old-line-format='' --unchanged-line-format='' "$1" "$2")
+REMOVED=$(diff --new-line-format='' --old-line-format='%L' --unchanged-line-format='' "$1" "$2")
+TOTAL=$(cat "$2")
+
+STATS_OLD=$(grep -E '^STAT:' "$1" | sed -E 's/^STAT://')
+STATS_NEW=$(grep -E '^STAT:' "$2" | sed -E 's/^STAT://')
+
+STATS_DIFFED=$(diff --new-line-format='+%L' --old-line-format='-%L' --unchanged-line-format=' %L' <(echo "$STATS_OLD") <(echo "$STATS_NEW"))
+
+ADDED_DEPRECATIONS=$(grep -Pi '\b(deprecation|deprecated)\b' <<< "$ADDED")
+REMOVED_DEPRECATIONS=$(grep -Pi '\b(deprecation|deprecated)\b' <<< "$REMOVED")
+ADDED_WARNINGS=$(grep -Pi '\b(warn|warning)\b' <<< "$ADDED")
+REMOVED_WARNINGS=$(grep -Pi '\b(warn|warning)\b' <<< "$REMOVED")
+
+DEPRECATION_COUNT=$(grep -Pi '\b(deprecation|deprecated)\b' <<< "$TOTAL" | wc -l)
+WARNING_COUNT=$(grep -Pi '\b(warn|warning)\b' <<< "$TOTAL" | wc -l)
+
+if [ -z "$ADDED_DEPRECATIONS" ]; then
+	# no new deprecations
+	true
+else
+	echo "⚠️ This PR introduces new deprecations:"
+	echo
+	echo '```'
+	echo "$ADDED_DEPRECATIONS"
+	echo '```'
+	echo
+	EMPTY=0
+fi
+
+if [ -z "$ADDED_WARNINGS" ]; then
+	# no new deprecations
+	true
+else
+	echo "⚠️ This PR introduces new warnings:"
+	echo
+	echo '```'
+	echo "$ADDED_WARNINGS"
+	echo '```'
+	echo
+	EMPTY=0
+fi
+
+if grep "DCD BUILD FAILED" <<< "$TOTAL"; then
+	echo '❌ Basic `dub build` failed! Please check your changes again.'
+	echo
+else
+	if [ -z "$REMOVED_DEPRECATIONS" ]; then
+		# no removed deprecations
+		true
+	else
+		echo "✅ This PR fixes following deprecations:"
+		echo
+		echo '```'
+		echo "$REMOVED_DEPRECATIONS"
+		echo '```'
+		echo
+		EMPTY=0
+	fi
+
+	if [ -z "$REMOVED_WARNINGS" ]; then
+		# no removed warnings
+		true
+	else
+		echo "✅ This PR fixes following warnings:"
+		echo
+		echo '```'
+		echo "$REMOVED_WARNINGS"
+		echo '```'
+		echo
+		EMPTY=0
+	fi
+
+	if [ $EMPTY == 1 ]; then
+		echo "✅ PR OK, no changes in deprecations or warnings"
+		echo
+	fi
+
+	echo "Total deprecations: $DEPRECATION_COUNT"
+	echo
+	echo "Total warnings: $WARNING_COUNT"
+	echo
+fi
+
+if [ -z "$STATS_DIFFED" ]; then
+	# no statistics?
+	true
+else
+	echo "Build statistics:"
+	echo
+	echo '```diff'
+	echo "$STATS_DIFFED"
+	echo '```'
+	echo
+fi
+
+echo '<details>'
+echo
+echo '<summary>Full build output</summary>'
+echo
+echo '```'
+echo "$TOTAL"
+echo '```'
+echo
+echo '</details>'

common/src/dcd/common/constants2.d

@@ -21,10 +21,12 @@ immutable ConstantCompletion[] pragmas = [
 immutable ConstantCompletion[] traits = [
 	// generated from traits.dd
 	ConstantCompletion("allMembers", `$(P Takes a single argument, which must evaluate to either
-a type or an expression of type.
-A tuple of string literals is returned, each of which
-is the name of a member of that type combined with all
-of the members of the base classes (if the type is a class).
+a module, a struct, a union, a class, an interface, an enum, or a
+template instantiation.
+
+A sequence of string literals is returned, each of which
+is the name of a member of that argument combined with all
+of the members of its base classes (if the argument is a class).
 No name is repeated.
 Builtin properties are not included.
 )
@@ -53,6 +55,59 @@ void main()
 
 $(P The order in which the strings appear in the result
 is not defined.)`),
+	ConstantCompletion("child", `$(P Takes two arguments.
+The first must be a symbol or expression.
+The second is a symbol, such as an alias to a member of the first
+argument.
+The result is the second argument interpreted with its $(D this)
+context set to the value of the first argument.
+)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+import std.stdio;
+
+struct A
+{
+    int i;
+    int foo(int j) {
+        return i * j;
+    }
+    T bar(T)(T t) {
+        return i + t;
+    }
+}
+
+alias Ai = A.i;
+alias Abar = A.bar!int;
+
+void main()
+{
+    A a;
+
+    __traits(child, a, Ai) = 3;
+    writeln(a.i);
+    writeln(__traits(child, a, A.foo)(2));
+    writeln(__traits(child, a, Abar)(5));
+}
+---
+)
+
+Prints:
+
+$(CONSOLE
+3
+6
+8
+)`),
+	ConstantCompletion("classInstanceAlignment", `$(P Takes a single argument, which must evaluate to either
+a class type or an expression of class type.
+The result
+is of type $(CODE size_t), and the value is the alignment
+of a runtime instance of the class type.
+It is based on the static type of a class, not the
+polymorphic type.
+)`),
 	ConstantCompletion("classInstanceSize", `$(P Takes a single argument, which must evaluate to either
 a class type or an expression of class type.
 The result
@@ -109,7 +164,7 @@ partial specialization allows for.)
 )`),
 	ConstantCompletion("derivedMembers", `$(P Takes a single argument, which must evaluate to either
 a type or an expression of type.
-A tuple of string literals is returned, each of which
+A sequence of string literals is returned, each of which
 is the name of a member of that type.
 No name is repeated.
 Base class member names are not included.
@@ -139,7 +194,7 @@ void main()
 $(P The order in which the strings appear in the result
 is not defined.)`),
 	ConstantCompletion("getAliasThis", `$(P Takes one argument, a type. If the type has ` ~ "`" ~ `alias this` ~ "`" ~ ` declarations,
-    returns a sequence of the names (as ` ~ "`" ~ `string` ~ "`" ~ `s) of the members used in
+    returns a *ValueSeq* of the names (as ` ~ "`" ~ `string` ~ "`" ~ `s) of the members used in
     those declarations. Otherwise returns an empty sequence.
 )
 
@@ -167,8 +222,8 @@ tuple("var")
 tuple()
 )`),
 	ConstantCompletion("getAttributes", `$(P
-    Takes one argument, a symbol. Returns a tuple of all attached user-defined attributes.
-    If no UDAs exist it will return an empty tuple.
+    Takes one argument, a symbol. Returns a sequence of all attached user-defined attributes.
+    If no UDAs exist it will return an empty sequence
 )
 
 $(P
@@ -196,22 +251,40 @@ tuple(3)
 tuple("string", 7)
 tuple((Foo))
 )
+)`),
+	ConstantCompletion("getCppNamespaces", `$(P The argument is a symbol.
+The result is a *ValueSeq* of strings, possibly empty, that correspond to the namespaces the symbol resides in.
+)
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+extern(C++, "ns")
+struct Foo {}
+struct Bar {}
+extern(C++, __traits(getCppNamespaces, Foo)) struct Baz {}
+static assert(__traits(getCppNamespaces, Foo) ==  __traits(getCppNamespaces, Baz));
+void main()
+{
+    static assert(__traits(getCppNamespaces, Foo)[0] == "ns");
+    static assert(!__traits(getCppNamespaces, Bar).length);
+    static assert(__traits(getCppNamespaces, Foo) ==  __traits(getCppNamespaces, Baz));
+}
+---
 )`),
 	ConstantCompletion("getFunctionAttributes", `$(P
     Takes one argument which must either be a function symbol, function literal,
-    or a function pointer. It returns a string tuple of all the attributes of
+    or a function pointer. It returns a string *ValueSeq* of all the attributes of
     that function $(B excluding) any user-defined attributes (UDAs can be
-    retrieved with the $(RELATIVE_LINK2 get-attributes, getAttributes) trait).
-    If no attributes exist it will return an empty tuple.
+    retrieved with the $(GLINK getAttributes) trait).
+    If no attributes exist it will return an empty sequence.
 )
 
 
-    $(B Note:) The order of the attributes in the returned tuple is
+    $(B Note:) The order of the attributes in the returned sequence is
     implementation-defined and should not be relied upon.
 
     $(P
         A list of currently supported attributes are:)
-        $(UL $(LI $(D pure), $(D nothrow), $(D @nogc), $(D @property), $(D @system), $(D @trusted), $(D @safe), and $(D ref)))
+        $(UL $(LI $(D pure), $(D nothrow), $(D @nogc), $(D @property), $(D @system), $(D @trusted), $(D @safe), $(D ref) and $(D @live)))
         $(B Note:) $(D ref) is a function attribute even though it applies to the return type.
 
     $(P
@@ -232,8 +305,6 @@ struct S
 }
 
 pragma(msg, __traits(getFunctionAttributes, S.test));
-
-void main(){}
 ---
 )
 
@@ -249,8 +320,6 @@ $(P Note that some attributes can be inferred. For example:)
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
 pragma(msg, __traits(getFunctionAttributes, (int x) @trusted { return x * 2; }));
-
-void main(){}
 ---
 )
 
@@ -329,6 +398,11 @@ static assert(__traits(getLinkage, FooCPPStruct) == "C++");
 static assert(__traits(getLinkage, FooCPPClass) == "C++");
 static assert(__traits(getLinkage, FooCPPInterface) == "C++");
 ---
+)`),
+	ConstantCompletion("getLocation", `$(P Takes one argument which is a symbol.
+To disambiguate between overloads, pass the result of $(GLINK getOverloads) with the desired index, to ` ~ "`" ~ `getLocation` ~ "`" ~ `.
+Returns a *ValueSeq* of a string and two ` ~ "`" ~ `int` ~ "`" ~ `s which correspond to the filename, line number and column number where the argument
+was declared.
 )`),
 	ConstantCompletion("getMember", `$(P Takes two arguments, the second must be a string.
 The result is an expression formed from the first
@@ -363,7 +437,7 @@ The second argument is a ` ~ "`" ~ `string` ~ "`" ~ ` that matches the name of
 the member(s) to return.
 The third argument is a ` ~ "`" ~ `bool` ~ "`" ~ `, and is optional.  If ` ~ "`" ~ `true` ~ "`" ~ `, the
 result will also include template overloads.
-The result is a tuple of all the overloads of the supplied name.
+The result is a symbol sequence of all the overloads of the supplied name.
 )
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
@@ -413,11 +487,11 @@ bar(int n)
 )`),
 	ConstantCompletion("getParameterStorageClasses", `$(P
     Takes two arguments.
-    The first must either be a function symbol, or a type
+    The first must either be a function symbol, a function call, or a type
     that is a function, delegate or a function pointer.
     The second is an integer identifying which parameter, where the first parameter is
     0.
-    It returns a tuple of strings representing the storage classes of that parameter.
+    It returns a *ValueSeq* of strings representing the storage classes of that parameter.
 )
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
@@ -430,6 +504,13 @@ static assert(__traits(getParameterStorageClasses, foo, 0)[1] == "ref");
 static assert(__traits(getParameterStorageClasses, foo, 1)[0] == "scope");
 static assert(__traits(getParameterStorageClasses, foo, 2)[0] == "out");
 static assert(__traits(getParameterStorageClasses, typeof(&foo), 3)[0] == "lazy");
+
+int* p, a;
+int b, c;
+
+static assert(__traits(getParameterStorageClasses, foo(p, a, b, c), 1)[0] == "scope");
+static assert(__traits(getParameterStorageClasses, foo(p, a, b, c), 2)[0] == "out");
+static assert(__traits(getParameterStorageClasses, foo(p, a, b, c), 3)[0] == "lazy");
 ---
 )`),
 	ConstantCompletion("getPointerBitmap", `$(P The argument is a type.
@@ -470,39 +551,7 @@ void main()
 }
 ---
 )`),
-	ConstantCompletion("getProtection", `$(P The argument is a symbol.
-The result is a string giving its protection level: "public", "private", "protected", "export", or "package".
-)
-
-$(SPEC_RUNNABLE_EXAMPLE_COMPILE
----
-import std.stdio;
-
-class D
-{
-    export void foo() { }
-    public int bar;
-}
-
-void main()
-{
-    D d = new D();
-
-    auto i = __traits(getProtection, d.foo);
-    writeln(i);
-
-    auto j = __traits(getProtection, d.bar);
-    writeln(j);
-}
----
-)
-
-Prints:
-
-$(CONSOLE
-export
-public
-)`),
+	ConstantCompletion("getProtection", `$(P A backward-compatible alias for $(GLINK getVisibility).)`),
 	ConstantCompletion("getTargetInfo", `$(P Receives a string key as argument.
 The result is an expression describing the requested target information.
 )
@@ -520,23 +569,24 @@ A reliable subset exists which are always available:
 
 $(UL
 $(LI $(D "cppRuntimeLibrary") - The C++ runtime library affinity for this toolchain)
+$(LI $(D "cppStd") - The version of the C++ standard supported by $(D extern$(LPAREN)C++$(RPAREN)) code, equivalent to the ` ~ "`" ~ `__cplusplus` ~ "`" ~ ` macro in a C++ compiler)
 $(LI $(D "floatAbi") - Floating point ABI; may be $(D "hard"), $(D "soft"), or $(D "softfp"))
 $(LI $(D "objectFormat") - Target object format)
 )`),
 	ConstantCompletion("getUnitTests", `$(P
         Takes one argument, a symbol of an aggregate (e.g. struct/class/module).
-        The result is a tuple of all the unit test functions of that aggregate.
+        The result is a symbol sequence of all the unit test functions of that aggregate.
         The functions returned are like normal nested static functions,
         $(DDSUBLINK glossary, ctfe, CTFE) will work and
         $(DDSUBLINK spec/attribute, uda, UDAs) will be accessible.
 )
 
-$(H3 Note:)
+$(H4 Note:)
 
 $(P
         The -unittest flag needs to be passed to the compiler. If the flag
         is not passed $(CODE __traits(getUnitTests)) will always return an
-        empty tuple.
+        empty sequence.
 )
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
@@ -612,7 +662,7 @@ a virtual function, $(D -1) is returned instead.
 class type.
 The second argument is a string that matches the name of
 one of the functions of that class.
-The result is a tuple of the virtual overloads of that function.
+The result is a symbol sequence of the virtual overloads of that function.
 It does not include final functions that do not override anything.
 )
 
@@ -653,6 +703,74 @@ int()
 void()
 int()
 2
+)`),
+	ConstantCompletion("getVisibility", `$(P The argument is a symbol.
+The result is a string giving its visibility level: "public", "private", "protected", "export", or "package".
+)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+import std.stdio;
+
+class D
+{
+    export void foo() { }
+    public int bar;
+}
+
+void main()
+{
+    D d = new D();
+
+    auto i = __traits(getVisibility, d.foo);
+    writeln(i);
+
+    auto j = __traits(getVisibility, d.bar);
+    writeln(j);
+}
+---
+)
+
+Prints:
+
+$(CONSOLE
+export
+public
+)`),
+	ConstantCompletion("hasCopyConstructor", `$(P The argument is a type. If it is a struct with a copy constructor, returns $(D true). Otherwise, return $(D false). Note that a copy constructor is distinct from a postblit.
+)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+
+import std.stdio;
+
+struct S
+{
+}
+
+class C
+{
+}
+
+struct P
+{
+    this(ref P rhs) {}
+}
+
+struct B
+{
+    this(this) {}
+}
+
+void main()
+{
+    writeln(__traits(hasCopyConstructor, S)); // false
+    writeln(__traits(hasCopyConstructor, C)); // false
+    writeln(__traits(hasCopyConstructor, P)); // true
+    writeln(__traits(hasCopyConstructor, B)); // false, this is a postblit
+}
+---
 )`),
 	ConstantCompletion("hasMember", `$(P The first argument is a type that has members, or
 is an expression of a type that has members.
@@ -668,8 +786,6 @@ import std.stdio;
 struct S
 {
     int m;
-
-    import std.stdio; // imports write
 }
 
 void main()
@@ -679,18 +795,52 @@ void main()
     writeln(__traits(hasMember, S, "m")); // true
     writeln(__traits(hasMember, s, "m")); // true
     writeln(__traits(hasMember, S, "y")); // false
-    writeln(__traits(hasMember, S, "write")); // true
+    writeln(__traits(hasMember, S, "write")); // false, but callable like a member via UFCS
     writeln(__traits(hasMember, int, "sizeof")); // true
 }
 ---
+)`),
+	ConstantCompletion("hasPostblit", `$(P The argument is a type. If it is a struct with a postblit, returns $(D true). Otherwise, return $(D false). Note a postblit is distinct from a copy constructor.
+)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+
+import std.stdio;
+
+struct S
+{
+}
+
+class C
+{
+}
+
+struct P
+{
+    this(ref P rhs) {}
+}
+
+struct B
+{
+    this(this) {}
+}
+
+
+void main()
+{
+    writeln(__traits(hasPostblit, S)); // false
+    writeln(__traits(hasPostblit, C)); // false
+    writeln(__traits(hasPostblit, P)); // false, this is a copy ctor
+    writeln(__traits(hasPostblit, B)); // true
+}
+---
 )`),
 	ConstantCompletion("identifier", `$(P Takes one argument, a symbol. Returns the identifier
 for that symbol as a string literal.
 )
-$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+$(SPEC_RUNNABLE_EXAMPLE_RUN
 ---
-import std.stdio;
-
 int var = 123;
 pragma(msg, typeof(var));                       // int
 pragma(msg, typeof(__traits(identifier, var))); // string
@@ -698,6 +848,47 @@ writeln(var);                                   // 123
 writeln(__traits(identifier, var));             // "var"
 ---
 )`),
+	ConstantCompletion("initSymbol", `$(P Takes a single argument, which must evaluate to a ` ~ "`" ~ `class` ~ "`" ~ `, ` ~ "`" ~ `struct` ~ "`" ~ ` or ` ~ "`" ~ `union` ~ "`" ~ ` type.
+    Returns a ` ~ "`" ~ `const(void)[]` ~ "`" ~ ` that holds the initial state of any instance of the supplied type.
+    The slice is constructed for any type ` ~ "`" ~ `T` ~ "`" ~ ` as follows:
+
+    - ` ~ "`" ~ `ptr` ~ "`" ~ ` points to either the initializer symbol of ` ~ "`" ~ `T` ~ "`" ~ `
+       or ` ~ "`" ~ `null` ~ "`" ~ ` if ` ~ "`" ~ `T` ~ "`" ~ ` is a zero-initialized struct / unions.
+
+    - ` ~ "`" ~ `length` ~ "`" ~ ` is equal to the size of an instance, i.e. ` ~ "`" ~ `T.sizeof` ~ "`" ~ ` for structs / unions and
+      $(RELATIVE_LINK2 classInstanceSize, $(D __traits(classInstanceSize, T)` ~ "`" ~ `)) for classes.
+)
+
+$(P
+    This trait matches the behaviour of ` ~ "`" ~ `TypeInfo.initializer()` ~ "`" ~ ` but can also be used when
+    ` ~ "`" ~ `TypeInfo` ~ "`" ~ ` is not available.
+)
+
+$(P
+    This traits is not available during $(DDSUBLINK glossary, ctfe, CTFE) because the actual address
+    of the initializer symbol will be set by the linker and hence is not available at compile time.
+)
+
+---
+class C
+{
+    int i = 4;
+}
+
+/// Initializes a malloc'ed instance of ` ~ "`" ~ `C` ~ "`" ~ `
+void main()
+{
+    const void[] initSym = __traits(initSymbol, C);
+
+    void* ptr = malloc(initSym.length);
+    scope (exit) free(ptr);
+
+    ptr[0..initSym.length] = initSym[];
+
+    C c = cast(C) ptr;
+    assert(c.i == 4);
+}
+---`),
 	ConstantCompletion("isAbstractClass", `$(P If the arguments are all either types that are abstract classes,
 or expressions that are typed as abstract classes, then $(D true)
 is returned.
@@ -766,6 +957,8 @@ is returned.
 Otherwise, $(D false) is returned.
 If there are no arguments, $(D false) is returned.)
 
+$(P Arithmetic types are integral types and floating point types.)
+
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
 import std.stdio;
@@ -791,6 +984,24 @@ false
 )`),
 	ConstantCompletion("isAssociativeArray", `$(P Works like $(D isArithmetic), except it's for associative array
 types.)`),
+	ConstantCompletion("isCopyable", `$(P Takes one argument. If that argument is a copyable type then $(D true) is returned,
+otherwise $(D false).
+)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+struct S
+{
+}
+static assert( __traits(isCopyable, S));
+
+struct T
+{
+    @disable this(this); // disable copy construction
+}
+static assert(!__traits(isCopyable, T));
+---
+)`),
 	ConstantCompletion("isDeprecated", `$(P Takes one argument. It returns ` ~ "`" ~ `true` ~ "`" ~ ` if the argument is a symbol
 marked with the ` ~ "`" ~ `deprecated` ~ "`" ~ ` keyword, otherwise ` ~ "`" ~ `false` ~ "`" ~ `.)`),
 	ConstantCompletion("isDisabled", `$(P Takes one argument and returns ` ~ "`" ~ `true` ~ "`" ~ ` if it's a function declaration
@@ -854,8 +1065,17 @@ void main()
 }
 ---
 )`),
-	ConstantCompletion("isFloating", `$(P Works like $(D isArithmetic), except it's for floating
-point types (including imaginary and complex types).)
+	ConstantCompletion("isFloating", `$(P If the arguments are all either types that are floating point types,
+or expressions that are typed as floating point types, then $(D true)
+is returned.
+Otherwise, $(D false) is returned.
+If there are no arguments, $(D false) is returned.)
+
+$(P The floating point types are:
+` ~ "`" ~ `float` ~ "`" ~ `, ` ~ "`" ~ `double` ~ "`" ~ `, ` ~ "`" ~ `real` ~ "`" ~ `,
+` ~ "`" ~ `ifloat` ~ "`" ~ `, ` ~ "`" ~ `idouble` ~ "`" ~ `, ` ~ "`" ~ `ireal` ~ "`" ~ `,
+` ~ "`" ~ `cfloat` ~ "`" ~ `, ` ~ "`" ~ `cdouble` ~ "`" ~ `, ` ~ "`" ~ `creal` ~ "`" ~ `,
+vectors of floating point types, and enums with a floating point base type.)
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
@@ -864,8 +1084,6 @@ import core.simd : float4;
 enum E : float { a, b }
 
 static assert(__traits(isFloating, float));
-static assert(__traits(isFloating, idouble));
-static assert(__traits(isFloating, creal));
 static assert(__traits(isFloating, E));
 static assert(__traits(isFloating, float4));
 
@@ -875,8 +1093,16 @@ static assert(!__traits(isFloating, float[4]));
 	ConstantCompletion("isFuture", `$(P Takes one argument. It returns ` ~ "`" ~ `true` ~ "`" ~ ` if the argument is a symbol
 marked with the ` ~ "`" ~ `@future` ~ "`" ~ ` keyword, otherwise ` ~ "`" ~ `false` ~ "`" ~ `. Currently, only
 functions and variable declarations have support for the ` ~ "`" ~ `@future` ~ "`" ~ ` keyword.)`),
-	ConstantCompletion("isIntegral", `$(P Works like $(D isArithmetic), except it's for integral
-types (including character types).)
+	ConstantCompletion("isIntegral", `$(P If the arguments are all either types that are integral types,
+or expressions that are typed as integral types, then $(D true)
+is returned.
+Otherwise, $(D false) is returned.
+If there are no arguments, $(D false) is returned.)
+
+$(P The integral types are:
+` ~ "`" ~ `byte` ~ "`" ~ `, ` ~ "`" ~ `ubyte` ~ "`" ~ `, ` ~ "`" ~ `short` ~ "`" ~ `, ` ~ "`" ~ `ushort` ~ "`" ~ `, ` ~ "`" ~ `int` ~ "`" ~ `, ` ~ "`" ~ `uint` ~ "`" ~ `, ` ~ "`" ~ `long` ~ "`" ~ `, ` ~ "`" ~ `ulong` ~ "`" ~ `, ` ~ "`" ~ `cent` ~ "`" ~ `, ` ~ "`" ~ `ucent` ~ "`" ~ `,
+` ~ "`" ~ `bool` ~ "`" ~ `, ` ~ "`" ~ `char` ~ "`" ~ `, ` ~ "`" ~ `wchar` ~ "`" ~ `, ` ~ "`" ~ `dchar` ~ "`" ~ `,
+vectors of integral types, and enums with an integral base type.)
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
@@ -923,6 +1149,27 @@ void foolazy(lazy int x)
     static assert(__traits(isLazy, x));
 }
 ---
+)`),
+	ConstantCompletion("isModule", `$(P Takes one argument. If that argument is a symbol that refers to a
+$(DDLINK spec/module, Modules, module) then $(D true) is returned, otherwise $(D false).
+$(DDSUBLINK spec/module, package-module, Package modules) are considered to be
+modules even if they have not been directly imported as modules.
+)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+import core.thread;
+import std.algorithm.sorting;
+
+// A regular package (no package.d)
+static assert(!__traits(isModule, core));
+// A package module (has a package.d file)
+// Note that we haven't imported std.algorithm directly.
+// (In other words, we don't have an "import std.algorithm;" directive.)
+static assert(__traits(isModule, std.algorithm));
+// A regular module
+static assert(__traits(isModule, std.algorithm.sorting));
+---
 )`),
 	ConstantCompletion("isNested", `$(P Takes one argument.
 It returns $(D true) if the argument is a nested type which internally
@@ -988,6 +1235,17 @@ void main()
 )`),
 	ConstantCompletion("isPOD", `$(P Takes one argument, which must be a type. It returns
 $(D true) if the type is a $(DDSUBLINK glossary, pod, POD) type, otherwise $(D false).)`),
+	ConstantCompletion("isPackage", `$(P Takes one argument. If that argument is a symbol that refers to a
+$(DDSUBLINK spec/module, PackageName, package) then $(D true) is returned,
+otherwise $(D false).
+)
+
+---
+import std.algorithm.sorting;
+static assert(__traits(isPackage, std));
+static assert(__traits(isPackage, std.algorithm));
+static assert(!__traits(isPackage, std.algorithm.sorting));
+---`),
 	ConstantCompletion("isRef", `$(P Takes one argument. If that argument is a declaration,
 $(D true) is returned if it is $(D_KEYWORD ref), $(D_KEYWORD out),
 or $(D_KEYWORD lazy), otherwise $(D false).
@@ -1049,34 +1307,42 @@ $(LI When using inline assembly to correctly call a function.)
 $(LI Testing that the compiler does this correctly is normally hackish and awkward,
 this enables efficient, direct, and simple testing.)
 ))`),
-	ConstantCompletion("isSame", `$(P Takes two arguments and returns bool $(D true) if they
-are the same symbol, $(D false) if not.)
+	ConstantCompletion("isSame", `$(P Compares two arguments and evaluates to ` ~ "`" ~ `bool` ~ "`" ~ `.)
+
+$(P The result is ` ~ "`" ~ `true` ~ "`" ~ ` if the two arguments are the same symbol
+(once aliases are resolved).)
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
-import std.stdio;
-
 struct S { }
 
 int foo();
 int bar();
 
-void main()
-{
-    writeln(__traits(isSame, foo, foo)); // true
-    writeln(__traits(isSame, foo, bar)); // false
-    writeln(__traits(isSame, foo, S));   // false
-    writeln(__traits(isSame, S, S));     // true
-    writeln(__traits(isSame, std, S));   // false
-    writeln(__traits(isSame, std, std)); // true
-}
+static assert(__traits(isSame, foo, foo));
+static assert(!__traits(isSame, foo, bar));
+static assert(!__traits(isSame, foo, S));
+static assert(__traits(isSame, S, S));
+static assert(!__traits(isSame, object, S));
+static assert(__traits(isSame, object, object));
+
+alias daz = foo;
+static assert(__traits(isSame, foo, daz));
 ---
 )
 
-$(P If the two arguments are expressions made up of literals
-or enums that evaluate to the same value, true is returned.)
+$(P The result is ` ~ "`" ~ `true` ~ "`" ~ ` if the two arguments are expressions
+made up of literals or enums that evaluate to the same value.)
 
-$(P If the two arguments are both lambda functions (or aliases
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+enum e = 3;
+static assert(__traits(isSame, (e), 3));
+static assert(__traits(isSame, 5, 2 + e));
+---
+)
+$(P If the two arguments are both
+$(DDSUBLINK spec/expression, function_literals, lambda functions) (or aliases
 to lambda functions), then they are compared for equality. For
 the comparison to be computed correctly, the following conditions
 must be met for both lambda functions:)
@@ -1093,11 +1359,20 @@ statements, the function is considered incomparable.)
 )
 
 $(P If these constraints aren't fulfilled, the function is considered
-incomparable and ` ~ "`" ~ `isSame` ~ "`" ~ ` returns $(D false).)
+incomparable and the result is $(D false).)
 
+    $(SPEC_RUNNABLE_EXAMPLE_COMPILE
+    ---
+    static assert(__traits(isSame, (a, b) => a + b, (c, d) => c + d));
+    static assert(__traits(isSame, a => ++a, b => ++b));
+    static assert(!__traits(isSame, (int a, int b) => a + b, (a, b) => a + b));
+    static assert(__traits(isSame, (a, b) => a + b + 10, (c, d) => c + d + 10));
+    ---
+    )
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
 int f() { return 2; }
+
 void test(alias pred)()
 {
     // f() from main is a different function from top-level f()
@@ -1106,11 +1381,6 @@ void test(alias pred)()
 
 void main()
 {
-    static assert(__traits(isSame, (a, b) => a + b, (c, d) => c + d));
-    static assert(__traits(isSame, a => ++a, b => ++b));
-    static assert(!__traits(isSame, (int a, int b) => a + b, (a, b) => a + b));
-    static assert(__traits(isSame, (a, b) => a + b + 10, (c, d) => c + d + 10));
-
     // lambdas accessing local variables are considered incomparable
     int b;
     static assert(!__traits(isSame, a => a + b, a => a + b));
@@ -1119,34 +1389,65 @@ void main()
     int f() { return 3;}
     static assert(__traits(isSame, a => a + f(), a => a + f()));
     test!((int a) => a + f())();
-
+}
+---
+)
+    $(SPEC_RUNNABLE_EXAMPLE_COMPILE
+    ---
     class A
     {
-        int a;
-        this(int a)
-        {
-            this.a = a;
-        }
+int a;
+this(int a)
+{
+    this.a = a;
+}
     }
 
     class B
     {
-        int a;
-        this(int a)
-        {
-            this.a = a;
-        }
+int a;
+this(int a)
+{
+    this.a = a;
+}
     }
 
     static assert(__traits(isSame, (A a) => ++a.a, (A b) => ++b.a));
     // lambdas with different data types are considered incomparable,
     // even if the memory layout is the same
     static assert(!__traits(isSame, (A a) => ++a.a, (B a) => ++a.a));
-}
+    ---
+    )
+
+$(P If the two arguments are tuples then the result is ` ~ "`" ~ `true` ~ "`" ~ ` if the
+two tuples, after expansion, have the same length and if each pair
+of nth argument respects the constraints previously specified.)
+
+$(SPEC_RUNNABLE_EXAMPLE_COMPILE
+---
+import std.meta;
+
+struct S { }
+
+// like __traits(isSame,0,0) && __traits(isSame,1,1)
+static assert(__traits(isSame, AliasSeq!(0,1), AliasSeq!(0,1)));
+// like __traits(isSame,S,std.meta) && __traits(isSame,1,1)
+static assert(!__traits(isSame, AliasSeq!(S,1), AliasSeq!(std.meta,1)));
+// the length of the sequences is different
+static assert(!__traits(isSame, AliasSeq!(1), AliasSeq!(1,2)));
 ---
 )`),
-	ConstantCompletion("isScalar", `$(P Works like $(D isArithmetic), except it's for scalar
-types.)
+	ConstantCompletion("isScalar", `$(P If the arguments are all either types that are scalar types,
+or expressions that are typed as scalar types, then $(D true)
+is returned.
+Otherwise, $(D false) is returned.
+If there are no arguments, $(D false) is returned.)
+
+$(P Scalar types are integral types,
+floating point types,
+pointer types,
+vectors of scalar types,
+and enums with a scalar base type.)
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
@@ -1207,8 +1508,8 @@ void main()
 }
 ---
 )`),
-	ConstantCompletion("isTemplate", `$(P Takes one argument. If that argument is a template then $(D true) is returned,
-otherwise $(D false).
+	ConstantCompletion("isTemplate", `$(P Takes one argument. If that argument or any of its overloads is a template
+then $(D true) is returned, otherwise $(D false).
 )
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
@@ -1219,8 +1520,16 @@ static assert(!__traits(isTemplate,foo!int()));
 static assert(!__traits(isTemplate,"string"));
 ---
 )`),
-	ConstantCompletion("isUnsigned", `$(P Works like $(D isArithmetic), except it's for unsigned
-types.)
+	ConstantCompletion("isUnsigned", `$(P If the arguments are all either types that are unsigned types,
+or expressions that are typed as unsigned types, then $(D true)
+is returned.
+Otherwise, $(D false) is returned.
+If there are no arguments, $(D false) is returned.)
+
+$(P The unsigned types are:
+` ~ "`" ~ `ubyte` ~ "`" ~ `, ` ~ "`" ~ `ushort` ~ "`" ~ `, ` ~ "`" ~ `uint` ~ "`" ~ `, ` ~ "`" ~ `ulong` ~ "`" ~ `, ` ~ "`" ~ `ucent` ~ "`" ~ `,
+` ~ "`" ~ `bool` ~ "`" ~ `, ` ~ "`" ~ `char` ~ "`" ~ `, ` ~ "`" ~ `wchar` ~ "`" ~ `, ` ~ "`" ~ `dchar` ~ "`" ~ `,
+vectors of unsigned types, and enums with an unsigned base type.)
 
 $(SPEC_RUNNABLE_EXAMPLE_COMPILE
 ---
@@ -1295,9 +1604,87 @@ void test()
 class C { int x = -1; }
 
 static assert(__traits(isZeroInit, C));
+
+// For initializing arrays of element type ` ~ "`" ~ `void` ~ "`" ~ `.
+static assert(__traits(isZeroInit, void));
 ---
 )`),
+	ConstantCompletion("parameters", `$(P May only be used inside a function. Takes no arguments, and returns
+a sequence of the enclosing function's parameters.)
+
+$(P If the function is nested, the parameters returned are those of the
+inner function, not the outer one.)
+
+---
+int add(int x, int y)
+{
+    return x + y;
+}
+
+int forwardToAdd(int x, int y)
+{
+    return add(__traits(parameters));
+    // equivalent to;
+    //return add(x, y);
+}
+
+int nestedExample(int x)
+{
+    // outer function's parameters
+    static assert(typeof(__traits(parameters)).length == 1);
+
+    int add(int x, int y)
+    {
+        // inner function's parameters
+        static assert(typeof(__traits(parameters)).length == 2);
+        return x + y;
+    }
+
+    return add(x, x);
+}
+
+class C
+{
+    int opApply(int delegate(size_t, C) dg)
+    {
+        if (dg(0, this)) return 1;
+        return 0;
+    }
+}
+
+void foreachExample(C c, int x)
+{
+    foreach(idx; 0..5)
+    {
+        static assert(is(typeof(__traits(parameters)) == AliasSeq!(C, int)));
+    }
+    foreach(idx, elem; c)
+    {
+        //  __traits(parameters) sees past the delegate passed to opApply
+        static assert(is(typeof(__traits(parameters)) == AliasSeq!(C, int)));
+    }
+}
+---`),
 	ConstantCompletion("parent", `$(P Takes a single argument which must evaluate to a symbol.
 The result is the symbol that is the parent of it.
 )`),
+	ConstantCompletion("toType", `$(P Takes a single argument, which must evaluate to an expression of type ` ~ "`" ~ `string` ~ "`" ~ `.
+The contents of the string must correspond to the $(DDSUBLINK spec/abi, name_mangling, mangled contents of a type)
+that has been seen by the implementation.)
+
+$(P Only D mangling is supported. Other manglings, such as C++ mangling, are not.)
+
+$(P The value returned is a type.)
+
+---
+template Type(T) { alias Type = T; }
+
+Type!(__traits(toType, "i")) j = 3; // j is declared as type ` ~ "`" ~ `int` ~ "`" ~ `
+
+static assert(is(Type!(__traits(toType, (int*).mangleof)) == int*));
+
+__traits(toType, "i") x = 4; // x is also declared as type ` ~ "`" ~ `int` ~ "`" ~ `
+---
+
+$(RATIONALE Provides the inverse operation of the $(DDSUBLINK spec/property, mangleof, ` ~ "`" ~ `.mangleof` ~ "`" ~ `) property.)`),
 ];

common/src/dcd/common/messages.d

@@ -78,10 +78,12 @@ enum RequestKind : ushort
 	localUse =     	 0b00000010_00000000,
 	/// Remove import directory from server
 	removeImport =   0b00000100_00000000,
+    /// Get inlay hints
+	inlayHints =     0b00001000_00000000,
 
 	/// These request kinds require source code and won't be executed if there
 	/// is no source sent
-	requiresSourceCode = autocomplete | doc | symbolLocation | search | localUse,
+	requiresSourceCode = autocomplete | doc | symbolLocation | search | localUse | inlayHints,
 	// dfmt on
 }
 
@@ -260,36 +262,39 @@ AutocompleteResponse getResponse(Socket socket)
  */
 bool serverIsRunning(bool useTCP, string socketFile, ushort port)
 {
-	scope (failure)
-		return false;
-	AutocompleteRequest request;
-	request.kind = RequestKind.query;
-	Socket socket;
-	scope (exit)
-	{
-		socket.shutdown(SocketShutdown.BOTH);
-		socket.close();
-	}
-	version(Windows) useTCP = true;
-	if (useTCP)
-	{
-		socket = new TcpSocket(AddressFamily.INET);
-		socket.connect(new InternetAddress("localhost", port));
-	}
-	else
-	{
-		version(Windows) {} else
+	try {		
+		AutocompleteRequest request;
+		request.kind = RequestKind.query;
+		Socket socket;
+		scope (exit)
 		{
-			socket = new Socket(AddressFamily.UNIX, SocketType.STREAM);
-			socket.connect(new UnixAddress(socketFile));
+			socket.shutdown(SocketShutdown.BOTH);
+			socket.close();
 		}
+		version(Windows) useTCP = true;
+		if (useTCP)
+		{
+			socket = new TcpSocket(AddressFamily.INET);
+			socket.connect(new InternetAddress("localhost", port));
+		}
+		else
+		{
+			version(Windows) {} else
+			{
+				socket = new Socket(AddressFamily.UNIX, SocketType.STREAM);
+				socket.connect(new UnixAddress(socketFile));
+			}
+		}
+		socket.setOption(SocketOptionLevel.SOCKET, SocketOption.RCVTIMEO, dur!"seconds"(5));
+		socket.blocking = true;
+		if (sendRequest(socket, request))
+			return getResponse(socket).completionType == "ack";
+		else
+			return false;
 	}
-	socket.setOption(SocketOptionLevel.SOCKET, SocketOption.RCVTIMEO, dur!"seconds"(5));
-	socket.blocking = true;
-	if (sendRequest(socket, request))
-		return getResponse(socket).completionType == "ack";
-	else
+	catch (Exception _) {
 		return false;
+	}
 }
 
 /// Escapes \n, \t and \ in the string. If `single` is true \t won't be escaped.

common/src/dcd/common/socket.d

@@ -27,6 +27,9 @@ version (OSX) version = haveUnixSockets;
 version (linux) version = haveUnixSockets;
 version (BSD) version = haveUnixSockets;
 version (FreeBSD) version = haveUnixSockets;
+version (OpenBSD) version = haveUnixSockets;
+version (NetBSD) version = haveUnixSockets;
+version (DragonflyBSD) version = haveUnixSockets;
 
 enum DEFAULT_PORT_NUMBER = 9166;
 

constants-gen/generator.d

@@ -135,6 +135,11 @@ ConstantCompletion[] parseTraits(string ddoc)
 			foundTerminator = true;
 			break;
 		}
+		else if (line.startsWith("$(H2 $(LNAME2"))
+		{
+			addCurrent();
+			seekingToFirst = true;
+		}
 		else if (line.canFind("$(GNAME "))
 		{
 			addCurrent();

constants-gen/pragma.dd

@@ -5,23 +5,29 @@ $(SPEC_S Pragmas,
 $(HEADERNAV_TOC)
 
 $(GRAMMAR
+$(GNAME PragmaDeclaration):
+    $(GLINK Pragma) $(D ;)
+    $(GLINK Pragma) $(GLINK2 attribute, DeclarationBlock)
+
+$(GNAME PragmaStatement):
+    $(GLINK Pragma) $(D ;)
+    $(GLINK Pragma) $(GLINK2 statement, NoScopeStatement)
+
 $(GNAME Pragma):
     $(D pragma) $(D $(LPAREN)) $(GLINK_LEX Identifier) $(D $(RPAREN))
     $(D pragma) $(D $(LPAREN)) $(GLINK_LEX Identifier) $(D ,) $(GLINK2 expression, ArgumentList) $(D $(RPAREN))
 )
 
 
-        $(P Pragmas are a way to pass special information to the compiler
-        and to add vendor specific extensions to D.
-        Pragmas can be used by themselves terminated with a $(SINGLEQUOTE ;),
-        they can influence a statement, a block of statements, a declaration, or
+        $(P Pragmas pass special information to the implementation
+        and can add vendor specific extensions.
+        Pragmas can be used by themselves terminated with a $(TT ;),
+        and can apply to a statement, a block of statements, a declaration, or
         a block of declarations.
         )
 
-        $(P Pragmas can appear as either declarations,
-        $(I Pragma) $(GLINK2 attribute, DeclarationBlock),
-        or as statements,
-        $(GLINK2 statement, PragmaStatement).
+        $(P Pragmas can be either a $(GLINK PragmaDeclaration)
+        or a $(GLINK PragmaStatement).
         )
 
 -----------------
@@ -60,23 +66,143 @@ $(H2 $(LEGACY_LNAME2 Predefined-Pragmas, predefined-pragmas, Predefined Pragmas)
 $(P All implementations must support these, even if by just ignoring them:)
 
 $(UL
+    $(LI $(LINK2 #crtctor, pragma crt$(UNDERSCORE)constructor))
+    $(LI $(LINK2 #crtdtor, pragma crt$(UNDERSCORE)destructor))
     $(LI $(LINK2 #inline, pragma inline))
     $(LI $(LINK2 #lib, pragma lib))
     $(LI $(LINK2 #linkerDirective, pragma linkerDirective))
     $(LI $(LINK2 #mangle, pragma mangle))
     $(LI $(LINK2 #msg, pragma msg))
+    $(LI $(LINK2 #printf, pragma printf))
+    $(LI $(LINK2 #scanf, pragma scanf))
     $(LI $(LINK2 #startaddress, pragma startaddress))
 )
 
     $(IMPLEMENTATION_DEFINED An implementation may ignore these pragmas.)
 
+$(H3 $(LNAME2 crtctor, $(D pragma crt_constructor)))
+
+    $(P Annotates a function so it is run after the C runtime library is initialized
+        and before the D runtime library is initialized.
+    )
+
+    $(P The function must:)
+
+    $(OL
+        $(LI be `extern (C)`)
+        $(LI not have any parameters)
+        $(LI not be a non-static member function)
+        $(LI be a function definition, not a declaration (i.e. it must have a function body))
+        $(LI not return a type that has a destructor)
+        $(LI not be a nested function)
+    )
+
+    ---
+    __gshared int initCount;
+
+    pragma(crt_constructor)
+    extern(C) void initializer() { initCount += 1; }
+    ---
+
+    $(P No arguments to the pragma are allowed.)
+
+    $(P A function may be annotated with both `pragma(crt_constructor)`
+        and `pragma(crt_destructor)`.
+    )
+
+    $(P Annotating declarations other than function definitions has no effect.)
+
+    $(P Annotating a struct or class definition does not affect the members of
+    the aggregate.)
+
+    $(P A function that is annotated with `pragma(crt_constructor)` may initialize
+    `const` or `immutable` variables.)
+
+    $(BEST_PRACTICE Use for system programming and interfacing with C/C++,
+        for example to allow for initialization of the runtime when loading a DSO,
+        or as a simple replacement for `shared static this` in
+        $(DDLINK spec/betterc, betterC mode, betterC mode).
+    )
+
+    $(IMPLEMENTATION_DEFINED The order in which functions annotated with `pragma(crt_constructor)`
+        are run is implementation defined.
+    )
+
+    $(BEST_PRACTICE to control the order in which the functions are called within one module, write
+        a single function that calls them in the desired order, and only annotate that function.
+    )
+
+    $(IMPLEMENTATION_DEFINED This uses the mechanism C compilers use to run
+        code before `main()` is called. C++ compilers use it to run static
+        constructors and destructors.
+        For example, GCC's $(LINK2 https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html, `__attribute__((constructor))`)
+        is equivalent.
+        Digital Mars C uses $(TT _STI) and $(TT _STD) identifier prefixes to mark crt_constructor and crt_destructor functions.
+    )
+
+    $(IMPLEMENTATION_DEFINED
+        A reference to the annotated function will be inserted in
+        the $(TT .init_array) section for Elf systems,
+        the $(TT XI) section for Win32 OMF systems,
+        the $(TT .CRT$XCU) section for Windows MSCOFF systems,
+        and the $(TT __mod_init_func) section for OSX systems.
+    )
+
+    $(NOTE `crt_constructor` and `crt_destructor` were implemented in
+        $(LINK2 $(ROOT_DIR)changelog/2.078.0.html, v2.078.0 (2018-01-01)).
+        Some compilers exposed non-standard, compiler-specific mechanism before.
+    )
+
+$(H3 $(LNAME2 crtdtor, $(D pragma crt_destructor)))
+
+    $(P `pragma(crt_destructor)` works the same as `pragma(crt_constructor)` except:)
+
+    $(OL
+        $(LI Annotates a function so it is run after the D runtime library is terminated
+             and before the C runtime library is terminated.
+             Calling C's `exit()` function also causes the annotated functions to run.)
+        $(LI The order in which the annotated functions are run is the reverse of those functions
+             annotated with `pragma(crt_constructor)`.)
+    )
+
+    $(IMPLEMENTATION_DEFINED This uses the mechanism C compilers use to run
+        code after `main()` returns or `exit()` is called. C++ compilers use it to run static
+        destructors.
+        For example, GCC's $(LINK2 https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html, `__attribute__((destructor))`)
+        is equivalent.
+        Digital Mars C uses $(TT _STI) and $(TT _STD) identifier prefixes to mark crt_constructor and crt_destructor functions.
+    )
+
+    $(IMPLEMENTATION_DEFINED
+        A reference to the annotated function will be inserted in
+        the $(TT .fini_array) section for Elf systems,
+        the $(TT XC) section for Win32 OMF systems,
+        the $(TT .CRT$XPU) section for Windows MSCOFF systems,
+        and the $(TT __mod_term_func) section for OSX systems.
+    )
+
+---
+__gshared int initCount;
+
+pragma(crt_constructor)
+extern(C) void initialize() { initCount += 1; }
+
+pragma(crt_destructor)
+extern(C) void deinitialize() { initCount -= 1; }
+
+pragma(crt_constructor)
+pragma(crt_destructor)
+extern(C) void innuendo() { printf("Inside a constructor... Or destructor?\n"); }
+---
+
+
 $(H3 $(LNAME2 inline, $(D pragma inline)))
 
     $(P Affects whether functions are inlined or not. If at the declaration level, it
      affects the functions declared in the block it controls. If inside a function, it
      affects the function it is enclosed by.)
 
-     $(P It takes three forms:)
+     $(P It takes two forms:)
      $(OL
         $(LI
 ---
@@ -86,21 +212,15 @@ pragma(inline)
         )
         $(LI
 ---
-pragma(inline, false)
+pragma(inline, AssignExpression)
 ---
-        Functions are never inlined.
-        )
-        $(LI
----
-pragma(inline, true)
----
-        Always inline the functions.
+        The $(GLINK2 expression, AssignExpression) is evaluated and must have a type that can be converted
+        to a boolean.
+        If the result is false the functions are never inlined, otherwise they are always inlined.
         )
       )
 
-    $(P There can be only zero or one $(I AssignExpression)s. If one is there, it must
-    be `true`, `false`, or an integer value. An integer value is implicitly converted
-    to a bool.)
+    $(P More than one $(I AssignExpression) is not allowed.)
 
     $(P If there are multiple pragma inlines in a function,
     the lexically last one takes effect.)
@@ -133,8 +253,8 @@ pragma(lib, "foo.lib");
 -----------------
 
     $(IMPLEMENTATION_DEFINED
-    Typically, the string literal specifies the file name of a library file. This name
-    is inserted into the generated object file, or otherwise is passed to the linker,
+    The string literal specifies the file name of a library file. This name
+    is inserted into the generated object file, or otherwise passed to the linker,
     so the linker automatically links in that library.
     )
 
@@ -147,44 +267,177 @@ pragma(linkerDirective, "/FAILIFMISMATCH:_ITERATOR_DEBUG_LEVEL=2");
 -----------------
 
     $(IMPLEMENTATION_DEFINED
-    $(P The string literal specifies a linker directive to be embedded in the generated object file.)
-
-    $(P Linker directives are only supported for MS-COFF output.)
+    The string literal specifies a linker directive to be embedded in the generated object file.
+    Linker directives are only supported for MS-COFF output.
     )
 
 $(H3 $(LNAME2 mangle, $(D pragma mangle)))
 
     $(P Overrides the default mangling for a symbol.)
 
-    $(P There must be one $(ASSIGNEXPRESSION) and it must evaluate at compile time to a string literal.
+    $(P For variables and functions there must be one $(ASSIGNEXPRESSION) and it must evaluate at compile time to a string literal.
+        For aggregates there may be one or two $(ASSIGNEXPRESSION)s, one of which must evaluate at compile time to a string literal and
+        one which must evaluate to a symbol. If that symbol is a $(I TemplateInstance), the aggregate is treated as a template
+        that has the signature and arguments of the $(I TemplateInstance). The identifier of the symbol is used when no string is supplied.
+        Both arguments may be used used when an aggregate's name is a D keyword.
     )
 
+    $(P It only applies to function and variable symbols. Other symbols are ignored.)
+
     $(IMPLEMENTATION_DEFINED On macOS and Win32, an extra underscore (`_`) is prepended to the string
         since 2.079, as is done by the C/C++ toolchain. This allows using the same `pragma(mangle)`
         for all compatible (POSIX in one case, win64 in another) platforms instead of having to special-case.
     )
 
-    $(IMPLEMENTATION_DEFINED It's only effective
-        when the symbol is a function declaration or a variable declaration.
-        For example this allows linking to a symbol which is a D keyword, which would normally
-        be disallowed as a symbol name:
+    $(RATIONALE
+        $(UL
+        $(LI Enables linking to symbol names that D cannot represent.)
+        $(LI Enables linking to a symbol which is a D keyword, since an $(GLINK_LEX Identifier)
+        cannot be a keyword.)
+        )
+        ---
+        pragma(mangle, "body")
+        extern(C) void body_func();
+        pragma(mangle, "function")
+        extern(C++) struct _function {}
+        template ScopeClass(C)
+        {
+            pragma(mangle, C.stringof, C)
+            struct ScopeClass { align(__traits(classInstanceAlignment, C)) void[__traits(classInstanceSize, C)] buffer; }
+        }
+        extern(C++)
+        {
+            class MyClassA(T) {}
+            void func(ref ScopeClass!(MyClassA!int)); // mangles as MyClass<int>&
+        }
+        ---
     )
------------------
-pragma(mangle, "body")
-extern(C) void body_func();
------------------
 
 
 $(H3 $(LNAME2 msg, $(D pragma msg)))
 
-    $(P Constructs a message from the $(I ArgumentList).)
+    $(P Each $(ASSIGNEXPRESSION) is evaluated at compile time and then all are combined into a message.)
+
+    ---
+    pragma(msg, "compiling...", 6, 1.0); // prints "compiling...61.0" at compile time
+    ---
+
+    $(IMPLEMENTATION_DEFINED The form the message takes and how it is presented to the user.
+    One way is by printing them to the standard error stream.)
+
+    $(RATIONALE Analogously to how `writeln()` performs a role of writing informational messages during runtime,
+        `pragma(msg)` performs the equivalent role at compile time.
+        For example,
+        ---
+        static if (kilroy)
+            pragma(msg, "Kilroy was here");
+        else
+            pragma(msg, "Kilroy got lost");
+        ---
+    )
+
+$(H3 $(LNAME2 printf, $(D pragma printf)))
+
+    $(P `pragma(printf)` specifies that a function declaration is a printf-like function, meaning
+    it is an `extern (C)` or `extern (C++)` function with a `format` parameter accepting a
+    pointer to a 0-terminated `char` string conforming to the C99 Standard 7.19.6.1, immediately followed
+    by either a `...` variadic argument list or a parameter of type `va_list` as the last parameter.
+    )
+
+    $(P If the `format` argument is a string literal, it is verified to be a valid format string
+    per the C99 Standard. If the `format` parameter is followed by `...`, the number and types
+    of the variadic arguments are checked against the format string.)
+
+    $(P Diagnosed incompatibilities are:)
+
+    $(UL
+    $(LI incompatible sizes which may cause argument misalignment)
+    $(LI deferencing arguments that are not pointers)
+    $(LI insufficient number of arguments)
+    $(LI struct arguments)
+    $(LI array and slice arguments)
+    $(LI non-pointer arguments to `s` specifier)
+    $(LI non-standard formats)
+    $(LI undefined behavior per C99)
+    )
+
+    $(P Per the C99 Standard, extra arguments are ignored.)
+
+    $(P Ignored mismatches are:)
+
+    $(UL
+    $(LI sign mismatches, such as printing an `int` with a `%u` format)
+    $(LI integral promotion mismatches, where the format specifies a smaller integral
+    type than `int` or `uint`, such as printing a `short` with the `%d` format rather than `%hd`)
+    )
+
+    ---
+    printf("%k\n", value); // error: non-Standard format k
+    printf("%d\n");        // error: not enough arguments
+    printf("%d\n", 1, 2);  // ok, extra arguments ignored
+    ---
+
+    $(BEST_PRACTICE
+    In order to use non-Standard printf/scanf formats, an easy workaround is:
+    ---
+    const format = "%k\n";
+    printf(format.ptr, value);  // no error
+    ---
+    )
+
+    $(BEST_PRACTICE
+    Most of the errors detected are portability issues. For instance,
+
+    ---
+    string s;
+    printf("%.*s\n", s.length, s.ptr);
+    printf("%d\n", s.sizeof);
+    ulong u;
+    scanf("%lld%*c\n", &u);
+    ---
+    should be replaced with:
+    ---
+    string s;
+    printf("%.*s\n", cast(int) s.length, s.ptr);
+    printf("%zd\n", s.sizeof);
+    ulong u;
+    scanf("%llu%*c\n", &u);
+    ---
+    )
+
+    $(P `pragma(printf)` applied to declarations that are not functions are ignored.
+    In particular, it has no effect on the declaration of a pointer to function type.
+    )
+
+
+$(H3 $(LNAME2 scanf, $(D pragma scanf)))
+
+    $(P `pragma(scanf)` specifies that a function declaration is a scanf-like function, meaning
+    it is an `extern (C)` or `extern (C++)` function with a `format` parameter accepting a
+    pointer to a 0-terminated `char` string conforming to the C99 Standard 7.19.6.2, immediately followed
+    by either a `...` variadic argument list or a parameter of type `va_list` as the last parameter.
+    )
+
+    $(P If the `format` argument is a string literal, it is verified to be a valid format string
+    per the C99 Standard. If the `format` parameter is followed by `...`, the number and types
+    of the variadic arguments are checked against the format string.)
+
+    $(P Diagnosed incompatibilities are:)
+
+    $(UL
+    $(LI argument is not a pointer to the format specified type)
+    $(LI insufficient number of arguments)
+    $(LI non-standard formats)
+    $(LI undefined behavior per C99)
+    )
+
+    $(P Per the C99 Standard, extra arguments are ignored.)
+
+    $(P `pragma(scanf)` applied to declarations that are not functions are ignored.
+    In particular, it has no effect on the declaration of a pointer to function type.
+    )
 
------------------
-pragma(msg, "compiling...", 1, 1.0);
------------------
 
-    $(IMPLEMENTATION_DEFINED The arguments are typically presented to the user during compilation,
-    such as by printing them to the standard error stream.)
 
 
 $(H3 $(LNAME2 startaddress, $(D pragma startaddress)))

dsymbol/dub.json

@@ -6,7 +6,7 @@
 	"targetPath": "build",
 	"targetType": "library",
 	"dependencies": {
-		"libdparse": ">=0.20.0 <1.0.0",
+		"libdparse": ">=0.23.0 <1.0.0",
 		"emsi_containers": "~>0.9.0"
 	}
 }

dsymbol/src/dsymbol/builtin/names.d

@@ -5,70 +5,232 @@ import dsymbol.string_interning;
 
 package istring[24] builtinTypeNames;
 
-/// Constants for buit-in or dummy symbol names
-istring FUNCTION_SYMBOL_NAME;
+// Constants for buit-in or dummy symbol names
+
+/**
+ * Type suffix, in breadcrumbs this appends ["callTip string", FUNCTION_SYMBOL_NAME]
+ *
+ * To check a DSymbol type for this name, instead check `qualifier == SymbolQualifier.func`
+ *
+ * This gets appended for `T delegate(Args)` types, with T as child type. The
+ * parameters are not currently resolved or exposed.
+ */
+@("function") istring FUNCTION_SYMBOL_NAME;
+/**
+ * Type suffix, in breadcrumbs this is a single entry.
+ *
+ * To check a DSymbol type for this name, instead check `qualifier == SymbolQualifier.array`
+ *
+ * This will appear as type name for `T[]` items, with T as child type.
+ *
+ * Index accessing an array DSymbol will either return itself for slices/ranges,
+ * or the child type for single index access.
+ */
+@("*arr*") istring ARRAY_SYMBOL_NAME;
+/**
+ * In breadcrumbs this is a single entry meaning that the type following this
+ * started with a dot `.`, so module scope instead of local scope is to be used
+ * for type resolution.
+ *
+ * Note that auto-completion does not rely on this symbol, only type / symbol
+ * lookup relies on this.
+ */
+@("*arr*") istring MODULE_SYMBOL_NAME;
+/**
+ * Type suffix, in breadcrumbs this is a single entry.
+ *
+ * To check a DSymbol type for this name, instead check `qualifier == SymbolQualifier.assocArray`
+ *
+ * This will appear as type name for `V[K]` items, with V as child type. K is
+ * not currently resolved or exposed.
+ *
+ * Index accessing an AA DSymbol will always return the child type.
+ */
+@("*aa*") istring ASSOC_ARRAY_SYMBOL_NAME;
+/**
+ * Type suffix, in breadcrumbs this is a single entry.
+ *
+ * To check a DSymbol type for this name, instead check `qualifier == SymbolQualifier.pointer`
+ *
+ * This will appear as type name for `T*` items, with T as child type.
+ *
+ * Pointer DSymbol types have special parts resolving mechanics, as they
+ * implicitly dereference single-layer pointers. Otherwise they also behave like
+ * arrays with index accessing.
+ */
+@("*") istring POINTER_SYMBOL_NAME;
+
+/** 
+ * Allocated as semantic symbol & DSymbol with this name + generates a new scope.
+ * Inserted for function literals. (e.g. delegates like `(foo) { ... }`)
+ *
+ * Only inserted for function literals with block statement and function body.
+ *
+ * Name of the function type is FUNCTION_LITERAL_SYMBOL_NAME, also being
+ * embedded inside the calltip.
+ */
+@("*function-literal*") istring FUNCTION_LITERAL_SYMBOL_NAME;
+/** 
+ * Generated from imports, where each full module/package import is a single
+ * semantic symbol & DSymbol. DSymbol's `skipOver` is set to true if it's not a
+ * public import. For each identifier inside the import identifier chain a
+ * DSymbol with the name set to the identifier is generated. The CompletionKind
+ * is `CompletionKind.packageName` for each of them, except for the final (last)
+ * identifier, which has `CompletionKind.moduleName`. Only the first identifier
+ * is added as child to the scope, then each identifier is added as child to the
+ * last one. Existing symbols are reused, so a full tree structure is built here.
+ *
+ * Import binds (`import importChain : a, b = c`) generate a semantic symbol for
+ * each bind, with the name being IMPORT_SYMBOL_NAME for symbols that are not
+ * renamed (`a` in this example) or the rename for symbols that are renamed (`b`
+ * in this example). Binds are resolved in the second pass via breadcrumbs. For
+ * the two binds in this example the breadcrumbs are `["a"]` and `["c", "b"]`
+ * respectively.
+ *
+ * An implicit `import object;` is generated and inserted as first child of each
+ * module, assuming `object` could be resolved.
+ *
+ * Additionally this symbol name is generated as DSymbol with
+ * CompletionKind.importSymbol in second pass for type inheritance, to import
+ * all children of the base type. Classes also get an additional
+ * $(LREF SUPER_SYMBOL_NAME) child as CompletionKind.variableName.
+ *
+ * `alias x this;` generates an IMPORT_SYMBOL_NAME DSymbol with
+ * CompletionKind.importSymbol, as well as adding itself to `aliasThisSymbols`
+ *
+ * `mixin Foo;` for Foo mixin templates generates an IMPORT_SYMBOL_NAME DSymbol
+ * with CompletionKind.importSymbol as child.
+ */
+@("import") istring IMPORT_SYMBOL_NAME;
+/** 
+ * Breadcrumb type that is emitted for array literals and array initializers.
+ *
+ * Gets built into an array DSymbol with the element type as child type and
+ * qualifier == SymbolQualifier.array. This has the same semantics as
+ * $(LREF ARRAY_SYMBOL_NAME) afterwards.
+ *
+ * Breadcrumb structure <first item initializer breadcrumbs> ~ [ARRAY_LITERAL_SYMBOL_NAME]
+ *
+ * Empty arrays insert `VOID_SYMBOL_NAME` in place of the first item initializer
+ * breadcrumbs.
+ */
+@("*arr-literal*") istring ARRAY_LITERAL_SYMBOL_NAME;
+/// unused currently, use-case unclear, might get removed or repurposed.
+@("*parameters*") istring PARAMETERS_SYMBOL_NAME;
+/// works pretty much like IMPORT_SYMBOL_NAME, but without renamed symbols. Can
+/// probably be merged into one.
+///
+/// Emitted for `with(x) { ... }` with WITH_SYMBOL_NAME as DSymbol and getting
+/// the value parsed as initializer.
+@("with") istring WITH_SYMBOL_NAME;
+/**
+ * Generated SemanticSymbol and DSymbol with this name for constructors.
+ * Otherwise behaves like functions, with CompletionKind.functionName, with no
+ * child type. The SemanticSymbol parent is the aggregate type. For the calltip,
+ * $(LREF THIS_SYMBOL_NAME) is used as name.
+ *
+ * Automatically generated for structs and unions if no explicit one is provided
+ * (with custom generated calltip).
+ *
+ * Symbols with this name are never returned as import child.
+ *
+ * Symbols with this name are excluded from auto-completion (only appear in calltips)
+ */
+@("*constructor*") istring CONSTRUCTOR_SYMBOL_NAME;
+/**
+ * Generated SemanticSymbol and DSymbol with this name for destructors.
+ * Otherwise behaves like functions, with CompletionKind.functionName, with no
+ * child type and no parameters. The calltip is hardcoded `~this()`
+ *
+ * Only emitted when explicitly written in code, not auto-generated.
+ *
+ * Symbols with this name are never returned as import child.
+ */
+@("~this") istring DESTRUCTOR_SYMBOL_NAME;
+/**
+ * Generated SemanticSymbol and DSymbol with this name for unittests.
+ * Otherwise behaves like functions, with CompletionKind.dummy, with no
+ * child type, no parameters and no symbol file.
+ *
+ * Due to being CompletionKind.dummy, this should never appear in any output.
+ *
+ * Symbols with this name are never returned as import child.
+ */
+@("*unittest*") istring UNITTEST_SYMBOL_NAME;
+/**
+ * Implicitly generated DSymbol for `this`. Child of structs, with type being
+ * set to the struct type.
+ *
+ * Symbols with this name are never returned as import child.
+ */
+@("this") istring THIS_SYMBOL_NAME;
+/// Currently unused, might get removed and implemented differently.
+@("_argptr") istring ARGPTR_SYMBOL_NAME;
+/// Currently unused, might get removed and implemented differently.
+@("_arguments") istring ARGUMENTS_SYMBOL_NAME;
+/**
+ * This symbol name is generated as DSymbol with CompletionKind.variableName in
+ * second pass for classes with inheritance, to import all children of the base
+ * class. DSymbol child of the class type, with the baseClass as its child type.
+ */
+@("super") istring SUPER_SYMBOL_NAME;
+/**
+ * This symbol name may appear at the start of breadcrumbs meaning the remaining
+ * breadcrumbs up until the matching $(LREF TYPEOF_END_SYMBOL_NAME) are an
+ * initializer or typeof expression. Pointer/Array suffixes are parsed
+ * beforehand, using popBack to remove them from the breadcrumbs.
+ *
+ * See_Also: $(LREF TYPEOF_END_SYMBOL_NAME)
+ */
+@("typeof(") istring TYPEOF_SYMBOL_NAME;
+/** 
+ * This symbol always appears in pairs with TYPEOF_SYMBOL_NAME, designates the
+ * end of the typeof expression in the breadcrumbs.
+ */
+@(")/*typeof*/") istring TYPEOF_END_SYMBOL_NAME;
+
+/**
+ * Breadcrumb part in initializer type generation for literal values in the
+ * source code.
+ *
+ * These match the built-in type names, but with prefixed `*` to indicate that
+ * they are values.
+ *
+ * $(LREF symbolNameToTypeName) converts the literal breadcrumb to a built-in
+ * type name, which is looked up in the module scope and used as initializer
+ * type. (first entry only)
+ */
+@("*double") istring DOUBLE_LITERAL_SYMBOL_NAME;
 /// ditto
-istring FUNCTION_LITERAL_SYMBOL_NAME;
+@("*float") istring FLOAT_LITERAL_SYMBOL_NAME;
 /// ditto
-istring IMPORT_SYMBOL_NAME;
+@("*idouble") istring IDOUBLE_LITERAL_SYMBOL_NAME;
 /// ditto
-istring ARRAY_SYMBOL_NAME;
+@("*ifloat") istring IFLOAT_LITERAL_SYMBOL_NAME;
 /// ditto
-istring ARRAY_LITERAL_SYMBOL_NAME;
+@("*int") istring INT_LITERAL_SYMBOL_NAME;
 /// ditto
-istring ASSOC_ARRAY_SYMBOL_NAME;
+@("*long") istring LONG_LITERAL_SYMBOL_NAME;
 /// ditto
-istring POINTER_SYMBOL_NAME;
+@("*real") istring REAL_LITERAL_SYMBOL_NAME;
 /// ditto
-istring PARAMETERS_SYMBOL_NAME;
+@("*ireal") istring IREAL_LITERAL_SYMBOL_NAME;
 /// ditto
-istring WITH_SYMBOL_NAME;
+@("*uint") istring UINT_LITERAL_SYMBOL_NAME;
 /// ditto
-istring CONSTRUCTOR_SYMBOL_NAME;
+@("*ulong") istring ULONG_LITERAL_SYMBOL_NAME;
 /// ditto
-istring DESTRUCTOR_SYMBOL_NAME;
+@("*char") istring CHAR_LITERAL_SYMBOL_NAME;
 /// ditto
-istring ARGPTR_SYMBOL_NAME;
+@("*dstring") istring DSTRING_LITERAL_SYMBOL_NAME;
 /// ditto
-istring ARGUMENTS_SYMBOL_NAME;
+@("*string") istring STRING_LITERAL_SYMBOL_NAME;
 /// ditto
-istring THIS_SYMBOL_NAME;
+@("*wstring") istring WSTRING_LITERAL_SYMBOL_NAME;
 /// ditto
-istring SUPER_SYMBOL_NAME;
+@("*bool") istring BOOL_VALUE_SYMBOL_NAME;
 /// ditto
-istring UNITTEST_SYMBOL_NAME;
-/// ditto
-istring DOUBLE_LITERAL_SYMBOL_NAME;
-/// ditto
-istring FLOAT_LITERAL_SYMBOL_NAME;
-/// ditto
-istring IDOUBLE_LITERAL_SYMBOL_NAME;
-/// ditto
-istring IFLOAT_LITERAL_SYMBOL_NAME;
-/// ditto
-istring INT_LITERAL_SYMBOL_NAME;
-/// ditto
-istring LONG_LITERAL_SYMBOL_NAME;
-/// ditto
-istring REAL_LITERAL_SYMBOL_NAME;
-/// ditto
-istring IREAL_LITERAL_SYMBOL_NAME;
-/// ditto
-istring UINT_LITERAL_SYMBOL_NAME;
-/// ditto
-istring ULONG_LITERAL_SYMBOL_NAME;
-/// ditto
-istring CHAR_LITERAL_SYMBOL_NAME;
-/// ditto
-istring DSTRING_LITERAL_SYMBOL_NAME;
-/// ditto
-istring STRING_LITERAL_SYMBOL_NAME;
-/// ditto
-istring WSTRING_LITERAL_SYMBOL_NAME;
-/// ditto
-istring BOOL_VALUE_SYMBOL_NAME;
-/// ditto
-istring VOID_SYMBOL_NAME;
+@("*void") istring VOID_SYMBOL_NAME;
 
 /**
  * Translates the IDs for built-in types into an interned string.
@@ -136,38 +298,16 @@ static this()
 	builtinTypeNames[22] = internString("cfloat");
 	builtinTypeNames[23] = internString("creal");
 
-	FUNCTION_SYMBOL_NAME = internString("function");
-	FUNCTION_LITERAL_SYMBOL_NAME = internString("*function-literal*");
-	IMPORT_SYMBOL_NAME = internString("import");
-	ARRAY_SYMBOL_NAME = internString("*arr*");
-	ARRAY_LITERAL_SYMBOL_NAME = internString("*arr-literal*");
-	ASSOC_ARRAY_SYMBOL_NAME = internString("*aa*");
-	POINTER_SYMBOL_NAME = internString("*");
-	PARAMETERS_SYMBOL_NAME = internString("*parameters*");
-	WITH_SYMBOL_NAME = internString("with");
-	CONSTRUCTOR_SYMBOL_NAME = internString("*constructor*");
-	DESTRUCTOR_SYMBOL_NAME = internString("~this");
-	ARGPTR_SYMBOL_NAME = internString("_argptr");
-	ARGUMENTS_SYMBOL_NAME = internString("_arguments");
-	THIS_SYMBOL_NAME = internString("this");
-	SUPER_SYMBOL_NAME = internString("super");
-	UNITTEST_SYMBOL_NAME = internString("*unittest*");
-	DOUBLE_LITERAL_SYMBOL_NAME = internString("*double");
-	FLOAT_LITERAL_SYMBOL_NAME = internString("*float");
-	IDOUBLE_LITERAL_SYMBOL_NAME = internString("*idouble");
-	IFLOAT_LITERAL_SYMBOL_NAME = internString("*ifloat");
-	INT_LITERAL_SYMBOL_NAME = internString("*int");
-	LONG_LITERAL_SYMBOL_NAME = internString("*long");
-	REAL_LITERAL_SYMBOL_NAME = internString("*real");
-	IREAL_LITERAL_SYMBOL_NAME = internString("*ireal");
-	UINT_LITERAL_SYMBOL_NAME = internString("*uint");
-	ULONG_LITERAL_SYMBOL_NAME = internString("*ulong");
-	CHAR_LITERAL_SYMBOL_NAME = internString("*char");
-	DSTRING_LITERAL_SYMBOL_NAME = internString("*dstring");
-	STRING_LITERAL_SYMBOL_NAME = internString("*string");
-	WSTRING_LITERAL_SYMBOL_NAME = internString("*wstring");
-	BOOL_VALUE_SYMBOL_NAME = internString("*bool");
-	VOID_SYMBOL_NAME = internString("*void");
+	static foreach (member; __traits(allMembers, dsymbol.builtin.names))
+	{
+		static if (member.length > 11 && member[$ - 11 .. $] == "SYMBOL_NAME"
+			&& is(typeof(__traits(getMember, dsymbol.builtin.names, member)) == istring))
+		{
+			__traits(getMember, dsymbol.builtin.names, member) = internString(
+				__traits(getAttributes, __traits(getMember, dsymbol.builtin.names, member))[0]
+			);
+		}
+	}
 }
 
 istring symbolNameToTypeName(istring name)
@@ -201,8 +341,8 @@ istring symbolNameToTypeName(istring name)
 	if (name == WSTRING_LITERAL_SYMBOL_NAME)
 		return istring("wstring");
 	if (name == BOOL_VALUE_SYMBOL_NAME)
-		return istring("bool");
+		return builtinTypeNames[13];
 	if (name == VOID_SYMBOL_NAME)
-		return istring("void");
+		return builtinTypeNames[14];
 	return name;
 }

dsymbol/src/dsymbol/builtin/symbols.d

@@ -45,6 +45,10 @@ TTree!(DSymbol*, SymbolsAllocator, true, "a < b") enumSymbols;
  */
 TTree!(DSymbol*, SymbolsAllocator, true, "a < b") pointerSymbols;
 
+/**
+ * Properties for the template arguments of declarations (none)
+ */
+TTree!(DSymbol*, SymbolsAllocator, true, "a < b") templatedSymbols;
 /**
  * Variadic template parameters properties
  */

dsymbol/src/dsymbol/conversion/first.d

@@ -33,11 +33,12 @@ import dsymbol.string_interning;
 import dsymbol.symbol;
 import dsymbol.type_lookup;
 import std.algorithm.iteration : map;
+import std.array : appender;
 import std.experimental.allocator;
 import std.experimental.allocator.gc_allocator : GCAllocator;
 import std.experimental.logger;
+import std.meta : AliasSeq;
 import std.typecons : Rebindable;
-import std.array : appender;
 
 /**
  * First Pass handles the following:
@@ -130,6 +131,7 @@ final class FirstPass : ASTVisitor
 		scope (exit) popSymbol();
 		currentSymbol.acSymbol.protection = protection.current;
 		currentSymbol.acSymbol.doc = makeDocumentation(dec.comment);
+		currentSymbol.acSymbol.qualifier = SymbolQualifier.func;
 
 		istring lastComment = this.lastComment;
 		this.lastComment = istring.init;
@@ -269,7 +271,7 @@ final class FirstPass : ASTVisitor
 					part.identifier.text, CompletionKind.variableName,
 					symbolFile, part.identifier.index);
 				symbol.parent = currentSymbol;
-				populateInitializer(symbol, part.initializer);
+				populateInitializer(symbol.typeLookups, part.initializer);
 				symbol.acSymbol.protection = protection.current;
 				symbol.acSymbol.doc = makeDocumentation(dec.comment);
 				currentSymbol.addChild(symbol, true);
@@ -717,26 +719,26 @@ final class FirstPass : ASTVisitor
 			currentSymbol.addChild(symbol, true);
 			currentScope.addSymbol(symbol.acSymbol, true);
 			if (symbol.typeLookups.empty && feExpression !is null)
-				populateInitializer(symbol, feExpression, true);
+				populateInitializer(symbol.typeLookups, feExpression, true);
 		}
 	}
 
 	override void visit(const IfStatement ifs)
 	{
-		if (ifs.identifier != tok!"" && ifs.thenStatement)
+		if (ifs.condition && ifs.condition.identifier != tok!"" && ifs.thenStatement)
 		{
 			pushScope(ifs.thenStatement.startLocation, ifs.thenStatement.endLocation);
 			scope(exit) popScope();
 
-			SemanticSymbol* symbol = allocateSemanticSymbol(ifs.identifier.text,
-				CompletionKind.variableName, symbolFile, ifs.identifier.index);
-			if (ifs.type !is null)
-				addTypeToLookups(symbol.typeLookups, ifs.type);
+			SemanticSymbol* symbol = allocateSemanticSymbol(ifs.condition.identifier.text,
+				CompletionKind.variableName, symbolFile, ifs.condition.identifier.index);
+			if (ifs.condition !is null && ifs.condition.type !is null)
+				addTypeToLookups(symbol.typeLookups, ifs.condition.type);
 			symbol.parent = currentSymbol;
 			currentSymbol.addChild(symbol, true);
 			currentScope.addSymbol(symbol.acSymbol, true);
-			if (symbol.typeLookups.empty && ifs.expression !is null)
-				populateInitializer(symbol, ifs.expression, false);
+			if (symbol.typeLookups.empty && ifs.condition !is null && ifs.condition.expression !is null)
+				populateInitializer(symbol.typeLookups, ifs.condition.expression, false);
 		}
 		ifs.accept(this);
 	}
@@ -754,7 +756,7 @@ final class FirstPass : ASTVisitor
 				currentScope.startLocation, null);
 			scope(exit) popSymbol();
 
-			populateInitializer(currentSymbol, withStatement.expression, false);
+			populateInitializer(currentSymbol.typeLookups, withStatement.expression, false);
 			withStatement.accept(this);
 
 		}
@@ -762,11 +764,12 @@ final class FirstPass : ASTVisitor
 			withStatement.accept(this);
 	}
 
-	override void visit(const ArgumentList list)
-	{
-		scope visitor = new ArgumentListVisitor(this);
-		visitor.visit(list);
-	}
+	static foreach (T; AliasSeq!(ArgumentList, NamedArgumentList))
+		override void visit(const T list)
+		{
+			scope visitor = new ArgumentListVisitor(this);
+			visitor.visit(list);
+		}
 
 	alias visit = ASTVisitor.visit;
 
@@ -906,7 +909,6 @@ private:
 			CompletionKind.functionName, symbolFile, location);
 		symbol.parent = currentSymbol;
 		currentSymbol.addChild(symbol, true);
-		processParameters(symbol, null, THIS_SYMBOL_NAME, parameters, templateParameters);
 		symbol.acSymbol.protection = protection.current;
 		symbol.acSymbol.doc = makeDocumentation(doc);
 
@@ -919,9 +921,16 @@ private:
 			pushFunctionScope(functionBody, location + 4); // 4 == "this".length
 			scope(exit) popScope();
 			currentSymbol = symbol;
+			processParameters(symbol, null, THIS_SYMBOL_NAME, parameters, templateParameters);
 			functionBody.accept(this);
 			currentSymbol = currentSymbol.parent;
 		}
+		else
+		{
+			currentSymbol = symbol;
+			processParameters(symbol, null, THIS_SYMBOL_NAME, parameters, templateParameters);
+			currentSymbol = currentSymbol.parent;
+		}
 	}
 
 	void visitDestructor(size_t location, const FunctionBody functionBody, string doc)
@@ -964,7 +973,39 @@ private:
 				if (p.type !is null)
 					addTypeToLookups(parameter.typeLookups, p.type);
 				parameter.parent = currentSymbol;
-				currentSymbol.acSymbol.argNames.insert(parameter.acSymbol.name);
+				foreach (const attribute; p.parameterAttributes)
+				{
+					switch (attribute.idType)
+					{
+					case tok!"ref":
+						if (!parameter.acSymbol.parameterIsAutoRef)
+							parameter.acSymbol.parameterIsRef = true;
+						break;
+					case tok!"auto":
+						// assume this is `auto ref`, since otherwise `auto` is
+						// not a valid parameter attribute.
+						if (!parameter.acSymbol.parameterIsRef)
+							parameter.acSymbol.parameterIsAutoRef = true;
+						break;
+					case tok!"scope":
+						parameter.acSymbol.parameterIsScope = true;
+						break;
+					case tok!"return":
+						parameter.acSymbol.parameterIsReturn = true;
+						break;
+					case tok!"lazy":
+						parameter.acSymbol.parameterIsLazy = true;
+						break;
+					case tok!"out":
+						parameter.acSymbol.parameterIsOut = true;
+						break;
+					case tok!"in":
+						parameter.acSymbol.parameterIsIn = true;
+						break;
+					default:
+						break;
+					}
+				}
 
 				currentSymbol.acSymbol.functionParameters ~= parameter.acSymbol;
 
@@ -1041,6 +1082,7 @@ private:
 					continue;
 				SemanticSymbol* templateParameter = allocateSemanticSymbol(name,
 					kind, symbolFile, index);
+				symbol.acSymbol.qualifier = SymbolQualifier.templated;
 				if (type !is null)
 					addTypeToLookups(templateParameter.typeLookups, type);
 
@@ -1085,13 +1127,24 @@ private:
 		return istring(app.data);
 	}
 
-	void populateInitializer(T)(SemanticSymbol* symbol, const T initializer,
-		bool appendForeach = false)
+	void populateInitializer(T)(ref TypeLookups lookups, const T initializer,
+		bool appendForeach = false, TypeLookup* l = null)
 	{
-		auto lookup = TypeLookupsAllocator.instance.make!TypeLookup(TypeLookupKind.initializer);
+		auto lookup = l ? l : TypeLookupsAllocator.instance.make!TypeLookup(TypeLookupKind.varOrFunType);
+
+		lookup.breadcrumbs.insert(TYPEOF_SYMBOL_NAME);
 		scope visitor = new InitializerVisitor(lookup, appendForeach, this);
-		symbol.typeLookups.insert(lookup);
-		visitor.visit(initializer);
+		scope (exit)
+			if (!visitor.isCast)
+				lookup.breadcrumbs.insert(TYPEOF_END_SYMBOL_NAME);
+
+		if (l is null)
+			lookups.insert(lookup);
+
+		static if (is(T == typeof(feExpression)))
+			visitor.dynamicDispatch(initializer);
+		else
+			visitor.visit(initializer);
 	}
 
 	SemanticSymbol* allocateSemanticSymbol(string name, CompletionKind kind,
@@ -1110,22 +1163,20 @@ private:
 		auto lookup = l !is null ? l : TypeLookupsAllocator.instance.make!TypeLookup(
 			TypeLookupKind.varOrFunType);
 		auto t2 = type.type2;
-		if (t2.type !is null)
-			addTypeToLookups(lookups, t2.type, lookup);
+		if (t2.typeofExpression !is null)
+			populateInitializer(lookups, t2.typeofExpression, false, lookup);
 		else if (t2.superOrThis is tok!"this")
 			lookup.breadcrumbs.insert(internString("this"));
 		else if (t2.superOrThis is tok!"super")
 			lookup.breadcrumbs.insert(internString("super"));
+
+		if (t2.type !is null)
+			addTypeToLookups(lookups, t2.type, lookup);
 		else if (t2.builtinType !is tok!"")
 			lookup.breadcrumbs.insert(getBuiltinTypeName(t2.builtinType));
 		else if (t2.typeIdentifierPart !is null)
 			writeIotcTo(t2.typeIdentifierPart, lookup.breadcrumbs);
-		else
-		{
-			// TODO: Add support for typeof expressions
-			// TODO: Add support for __vector
-//			warning("typeof() and __vector are not yet supported");
-		}
+		// TODO: support __vector, traits and mixin
 
 		foreach (suffix; type.typeSuffixes)
 		{
@@ -1307,6 +1358,10 @@ void writeIotcTo(T)(const TypeIdentifierPart tip, ref T output) nothrow
 {
 	if (!tip.identifierOrTemplateInstance)
 		return;
+
+	if (tip.dot)
+		output.insert(MODULE_SYMBOL_NAME);
+
 	if (tip.identifierOrTemplateInstance.identifier != tok!"")
 		output.insert(internString(tip.identifierOrTemplateInstance.identifier.text));
 	else
@@ -1361,6 +1416,7 @@ class InitializerVisitor : ASTVisitor
 	}
 
 	alias visit = ASTVisitor.visit;
+	alias dynamicDispatch = ASTVisitor.dynamicDispatch;
 
 	override void visit(const FunctionLiteralExpression exp)
 	{
@@ -1442,7 +1498,7 @@ class InitializerVisitor : ASTVisitor
 
 	override void visit(const IndexExpression expr)
 	{
-		expr.unaryExpression.accept(this);
+		dynamicDispatch(expr.unaryExpression);
 		foreach (index; expr.indexes)
 			if (index.high is null)
 				lookup.breadcrumbs.insert(ARRAY_SYMBOL_NAME);
@@ -1519,11 +1575,12 @@ class InitializerVisitor : ASTVisitor
 		ne.arguments = nace.constructorArguments;
 	}
 
-	override void visit(const ArgumentList list)
-	{
-		scope visitor = new ArgumentListVisitor(fp);
-		visitor.visit(list);
-	}
+	static foreach (T; AliasSeq!(ArgumentList, NamedArgumentList))
+		override void visit(const T list)
+		{
+			scope visitor = new ArgumentListVisitor(fp);
+			visitor.visit(list);
+		}
 
 	override void visit(const Expression expression)
 	{
@@ -1534,10 +1591,29 @@ class InitializerVisitor : ASTVisitor
 		on = false;
 	}
 
-	override void visit(const ExpressionNode expression)
+	override void visit(const CastExpression expression)
+	{
+		if (expression.type)
+		{
+			if (lookup.breadcrumbs.empty || lookup.breadcrumbs.back != TYPEOF_SYMBOL_NAME)
+				return;
+
+			isCast = true;
+			lookup.breadcrumbs.popBack();
+			TypeLookups none;
+			fp.addTypeToLookups(none, expression.type, lookup);
+		}
+		else
+		{
+			// we don't care about non-type casts (e.g. `cast()` or `cast(const)`) yet
+			expression.accept(this);
+		}
+	}
+
+	override void dynamicDispatch(const ExpressionNode expression)
 	{
 		on = true;
-		expression.accept(this);
+		super.dynamicDispatch(expression);
 		if (appendForeach)
 			lookup.breadcrumbs.insert(internString("foreach"));
 		on = false;
@@ -1547,6 +1623,7 @@ class InitializerVisitor : ASTVisitor
 	bool on = false;
 	const bool appendForeach;
 	FirstPass fp;
+	bool isCast;
 }
 
 class ArgumentListVisitor : ASTVisitor

dsymbol/src/dsymbol/conversion/package.d

@@ -51,7 +51,7 @@ ScopeSymbolPair generateAutocompleteTrees(const(Token)[] tokens,
 
 	secondPass(first.rootSymbol, first.moduleScope, cache);
 
-	thirdPass(first.moduleScope, cache, cursorPosition);
+	thirdPass(first.rootSymbol, first.moduleScope, cache, cursorPosition);
 
     auto ufcsSymbols = getUFCSSymbolsForCursor(first.moduleScope, tokens, cursorPosition);
 
@@ -115,6 +115,7 @@ class AutocompleteParser : Parser
 	{
 		if (!currentIs(tok!"{"))
 			return null;
+		if (cursorPosition == -1) return super.parseBlockStatement();
 		if (current.index > cursorPosition)
 		{
 			BlockStatement bs = allocator.make!(BlockStatement);

dsymbol/src/dsymbol/conversion/second.d

@@ -203,6 +203,7 @@ do
 		case SymbolQualifier.array: lastSuffix.addChildren(arraySymbols[], false); break;
 		case SymbolQualifier.assocArray: lastSuffix.addChildren(assocArraySymbols[], false); break;
 		case SymbolQualifier.pointer: lastSuffix.addChildren(pointerSymbols[], false); break;
+		case SymbolQualifier.templated: lastSuffix.addChildren(templatedSymbols[], false); break;
 		}
 
 		if (suffix is null)
@@ -236,16 +237,40 @@ do
 	}
 
 	// Follow all the names and try to resolve them
-	size_t i = 0;
-	foreach (part; lookup.breadcrumbs[])
+	bool first = true;
+	auto breadcrumbs = lookup.breadcrumbs[];
+
+	while (!breadcrumbs.empty)
 	{
-		if (i == 0)
+		auto part = breadcrumbs.front;
+		breadcrumbs.popFront();
+		scope (exit)
+			first = false;
+
+		if (part == TYPEOF_SYMBOL_NAME)
+		{
+			if (currentSymbol !is null)
+			{
+				warning("Invalid breadcrumbs, found `Type.typeof(...)`");
+				return;
+			}
+			resolveTypeFromInitializer(symbol, lookup, moduleScope, cache,
+				breadcrumbs, currentSymbol);
+		}
+		else if (first)
 		{
 			if (moduleScope is null)
 				getSymbolFromImports(imports, part);
 			else
 			{
-				auto symbols = moduleScope.getSymbolsByNameAndCursor(part, symbol.location);
+				auto symbols = part == MODULE_SYMBOL_NAME
+					? {
+						assert(!breadcrumbs.empty);
+						part = breadcrumbs.front;
+						breadcrumbs.popFront();
+						return moduleScope.getSymbolsByName(part);
+					}()
+					: moduleScope.getSymbolsByNameAndCursor(part, symbol.location);
 				if (symbols.length > 0)
 					currentSymbol = symbols[0];
 				else
@@ -272,7 +297,6 @@ do
 				return;
 			currentSymbol = currentSymbol.getFirstPartNamed(part);
 		}
-		++i;
 		if (currentSymbol is null)
 			return;
 	}
@@ -310,6 +334,110 @@ do
 	}
 }
 
+private void resolveTypeFromInitializer(R)(DSymbol* symbol, TypeLookup* lookup,
+	Scope* moduleScope, ref ModuleCache cache,
+	ref R breadcrumbs, ref DSymbol* currentSymbol)
+{
+	if (breadcrumbs.empty)
+		return;
+
+	bool first = true;
+	while (!breadcrumbs.empty)
+	{
+		auto crumb = breadcrumbs.front;
+		breadcrumbs.popFront();
+		if (crumb == TYPEOF_SYMBOL_NAME)
+		{
+			resolveTypeFromInitializer(symbol, lookup, moduleScope, cache,
+				breadcrumbs, currentSymbol);
+			if (currentSymbol is null)
+				return;
+			continue;
+		}
+		if (crumb == TYPEOF_END_SYMBOL_NAME)
+			break;
+
+		if (first)
+		{
+			first = false;
+			currentSymbol = moduleScope.getFirstSymbolByNameAndCursor(
+				symbolNameToTypeName(crumb), symbol.location);
+
+			if (currentSymbol is null)
+				return;
+		}
+		else if (crumb == ARRAY_LITERAL_SYMBOL_NAME)
+		{
+			auto arr = GCAllocator.instance.make!(DSymbol)(ARRAY_LITERAL_SYMBOL_NAME, CompletionKind.dummy, currentSymbol);
+			arr.qualifier = SymbolQualifier.array;
+			currentSymbol = arr;
+		}
+		else if (crumb == ARRAY_SYMBOL_NAME)
+		{
+			typeSwap(currentSymbol);
+			if (currentSymbol is null)
+				return;
+
+			// Index expressions can be on a pointer, an array or an AA
+			if (currentSymbol.qualifier == SymbolQualifier.array
+				|| currentSymbol.qualifier == SymbolQualifier.assocArray
+				|| currentSymbol.qualifier == SymbolQualifier.pointer
+				|| currentSymbol.kind == CompletionKind.aliasName)
+			{
+				// may become null, returns later
+				currentSymbol = currentSymbol.type;
+			}
+			else
+			{
+				auto opIndex = currentSymbol.getFirstPartNamed(internString("opIndex"));
+				if (opIndex !is null)
+				{
+					currentSymbol = opIndex.type;
+				}
+				else
+				{
+					currentSymbol = null;
+					return;
+				}
+			}
+		}
+		else if (crumb == "foreach")
+		{
+			typeSwap(currentSymbol);
+			if (currentSymbol is null)
+				return;
+			if (currentSymbol.qualifier == SymbolQualifier.array
+				|| currentSymbol.qualifier == SymbolQualifier.assocArray)
+			{
+				currentSymbol = currentSymbol.type;
+				continue;
+			}
+			auto front = currentSymbol.getFirstPartNamed(internString("front"));
+			if (front !is null)
+			{
+				currentSymbol = front.type;
+				continue;
+			}
+			auto opApply = currentSymbol.getFirstPartNamed(internString("opApply"));
+			if (opApply !is null)
+			{
+				currentSymbol = opApply.type;
+				continue;
+			}
+		}
+		else
+		{
+			typeSwap(currentSymbol);
+			if (currentSymbol is null)
+				return;
+			currentSymbol = currentSymbol.getFirstPartNamed(crumb);
+		}
+		if (currentSymbol is null)
+			return;
+	}
+	typeSwap(currentSymbol);
+}
+
 private:
 
 void resolveInheritance(DSymbol* symbol, ref TypeLookups typeLookups,
@@ -414,8 +542,6 @@ void resolveType(DSymbol* symbol, ref TypeLookups typeLookups,
 	foreach(lookup; typeLookups) {
 		if (lookup.kind == TypeLookupKind.varOrFunType)
 			resolveTypeFromType(symbol, lookup, moduleScope, cache, null);
-		else if (lookup.kind == TypeLookupKind.initializer)
-			resolveTypeFromInitializer(symbol, lookup, moduleScope, cache);
 		// issue 94
 		else if (lookup.kind == TypeLookupKind.inherit)
 			resolveInheritance(symbol, typeLookups, moduleScope, cache);
@@ -424,97 +550,6 @@ void resolveType(DSymbol* symbol, ref TypeLookups typeLookups,
 		}
 }
 
-void resolveTypeFromInitializer(DSymbol* symbol, TypeLookup* lookup,
-	Scope* moduleScope, ref ModuleCache cache)
-{
-	if (lookup.breadcrumbs.length == 0)
-		return;
-	DSymbol* currentSymbol = null;
-	size_t i = 0;
-
-	auto crumbs = lookup.breadcrumbs[];
-	foreach (crumb; crumbs)
-	{
-		if (i == 0)
-		{
-			currentSymbol = moduleScope.getFirstSymbolByNameAndCursor(
-				symbolNameToTypeName(crumb), symbol.location);
-
-			if (currentSymbol is null)
-				return;
-		}
-		else if (crumb == ARRAY_LITERAL_SYMBOL_NAME)
-		{
-			auto arr = GCAllocator.instance.make!(DSymbol)(ARRAY_LITERAL_SYMBOL_NAME, CompletionKind.dummy, currentSymbol);
-			arr.qualifier = SymbolQualifier.array;
-			currentSymbol = arr;
-		}
-		else if (crumb == ARRAY_SYMBOL_NAME)
-		{
-			typeSwap(currentSymbol);
-			if (currentSymbol is null)
-				return;
-
-			// Index expressions can be on a pointer, an array or an AA
-			if (currentSymbol.qualifier == SymbolQualifier.array
-				|| currentSymbol.qualifier == SymbolQualifier.assocArray
-				|| currentSymbol.qualifier == SymbolQualifier.pointer
-				|| currentSymbol.kind == CompletionKind.aliasName)
-			{
-				if (currentSymbol.type !is null)
-					currentSymbol = currentSymbol.type;
-				else
-					return;
-			}
-			else
-			{
-				auto opIndex = currentSymbol.getFirstPartNamed(internString("opIndex"));
-				if (opIndex !is null)
-					currentSymbol = opIndex.type;
-				else
-					return;
-			}
-		}
-		else if (crumb == "foreach")
-		{
-			typeSwap(currentSymbol);
-			if (currentSymbol is null)
-				return;
-			if (currentSymbol.qualifier == SymbolQualifier.array
-				|| currentSymbol.qualifier == SymbolQualifier.assocArray)
-			{
-				currentSymbol = currentSymbol.type;
-				break;
-			}
-			auto front = currentSymbol.getFirstPartNamed(internString("front"));
-			if (front !is null)
-			{
-				currentSymbol = front.type;
-				break;
-			}
-			auto opApply = currentSymbol.getFirstPartNamed(internString("opApply"));
-			if (opApply !is null)
-			{
-				currentSymbol = opApply.type;
-				break;
-			}
-		}
-		else
-		{
-			typeSwap(currentSymbol);
-			if (currentSymbol is null)
-				return;
-			currentSymbol = currentSymbol.getFirstPartNamed(crumb);
-		}
-		++i;
-		if (currentSymbol is null)
-			return;
-	}
-	typeSwap(currentSymbol);
-	symbol.type = currentSymbol;
-	symbol.ownType = false;
-}
-
 void typeSwap(ref DSymbol* currentSymbol)
 {
 	while (currentSymbol !is null && currentSymbol.type !is currentSymbol

dsymbol/src/dsymbol/conversion/third.d

@@ -34,10 +34,44 @@ import containers.hashset;
  * If it is, then it'll set its type
  * If the symbol is not found, then it'll do nothing 
  */
-void thirdPass(Scope* mscope, ref ModuleCache cache, size_t cursorPosition)
+void thirdPass(SemanticSymbol* root, Scope* mscope, ref ModuleCache cache, size_t cursorPosition)
 {
 	auto desired = mscope.getScopeByCursor(cursorPosition);
 	tryResolve(desired, cache);
+
+	// Check if there are any left out symbols
+	// Check issue 717 and test tc717
+	checkMissingTypes(root, mscope, cache);
+}
+
+void checkMissingTypes(SemanticSymbol* currentSymbol, Scope* moduleScope, ref ModuleCache cache)
+{
+	import dsymbol.conversion.second;
+	import dsymbol.type_lookup;
+
+	with (CompletionKind) switch (currentSymbol.acSymbol.kind)
+	{
+	case withSymbol:
+	case variableName:
+	case memberVariableName:
+	case functionName:
+	case ufcsName:
+	case aliasName:
+		if (currentSymbol.acSymbol.type is null)
+		{
+			if (currentSymbol.typeLookups.length == 0)
+				break;
+			auto lookup = currentSymbol.typeLookups.front;
+			if (lookup.kind == TypeLookupKind.varOrFunType)
+				resolveTypeFromType(currentSymbol.acSymbol, lookup, moduleScope, cache, null);
+		}
+		break;
+		default:
+		break;
+	}
+
+	foreach (child; currentSymbol.children)
+		checkMissingTypes(child, moduleScope, cache);
 }
 
 /**

dsymbol/src/dsymbol/symbol.d

@@ -133,6 +133,8 @@ enum SymbolQualifier : ubyte
 	selectiveImport,
 	/// The symbol is a pointer
 	pointer,
+	/// The symbol is templated
+	templated,
 }
 
 /**
@@ -232,7 +234,7 @@ struct DSymbol
 
 		// pointers are implicitly dereferenced on members (a single layer)
 		if (qualifier == SymbolQualifier.pointer
-			&& this.type.qualifier != SymbolQualifier.pointer)
+			&& (this.type && this.type.qualifier != SymbolQualifier.pointer))
 			return type.getParts!OR(name, app, visited, onlyOne);
 
 		if (name is null)
@@ -384,11 +386,6 @@ struct DSymbol
 
 	// Is alias this symbols
 	DSymbol*[] aliasThisSymbols;
-	/**
-	 * Names of function arguments
-	 */
-	// TODO: remove since we have function arguments
-	UnrolledList!(istring) argNames;
 
 	/**
 	 * Function parameter symbols
@@ -432,11 +429,41 @@ struct DSymbol
 	 * If true, this symbol owns its type and will free it on destruction
 	 */
 	// dfmt off
-	mixin(bitfields!(bool, "ownType", 1,
+	mixin(bitfields!(
+		bool, "ownType", 1,
 		bool, "skipOver", 1,
-		ubyte, "", 6));
+		bool, "_flag0", 1, // planned: const/immutable/shared/inout for types and parameters
+		bool, "_flag1", 1,
+		bool, "_flag2", 1,
+		bool, "_flag3", 1,
+		bool, "_flag4", 1,
+		bool, "_flag5", 1,
+		bool, "_flag6", 1,
+		bool, "_flag7", 1,
+		bool, "_flag8", 1,
+		bool, "_flag9", 1,
+		bool, "_flag10", 1,
+		uint, "", 3,
+	));
 	// dfmt on
 
+	/// Only valid for parameters: the parameter has storage class `ref` (not `auto ref`)
+	alias parameterIsRef = _flag4;
+	/// Only valid for parameters: the parameter has storage class `auto ref` (not `ref`)
+	alias parameterIsAutoRef = _flag5;
+	// TODO: maybe parameterIsScope and parameterIsReturn need to be differentiated for `scope return` and `return scope`?
+	// unsure about the needed semantics here.
+	/// Only valid for parameters: the parameter has storage class `scope`
+	alias parameterIsScope = _flag6;
+	/// Only valid for parameters: the parameter has storage class `return`
+	alias parameterIsReturn = _flag7;
+	/// Only valid for parameters: the parameter has storage class `lazy`
+	alias parameterIsLazy = _flag8;
+	/// Only valid for parameters: the parameter has storage class `out`
+	alias parameterIsOut = _flag9;
+	/// Only valid for parameters: the parameter has storage class `in`
+	alias parameterIsIn = _flag10;
+
 	deprecated bool isPointer()
 	{
 		return qualifier == SymbolQualifier.pointer;

dsymbol/src/dsymbol/tests.d

@@ -335,6 +335,8 @@ unittest
 		DSymbol* S = pair.symbol.getFirstPartNamed(internString("S"));
 		DSymbol* b = pair.symbol.getFirstPartNamed(internString("b"));
 		assert(S);
+		assert(b);
+		assert(b.type);
 		assert(b.type is S);
 	}
 	{
@@ -343,6 +345,8 @@ unittest
 		DSymbol* S = pair.symbol.getFirstPartNamed(internString("S"));
 		DSymbol* b = pair.symbol.getFirstPartNamed(internString("b"));
 		assert(S);
+		assert(b);
+		assert(b.type);
 		assert(b.type is S);
 	}
 	{
@@ -351,6 +355,8 @@ unittest
 		DSymbol* S = pair.symbol.getFirstPartNamed(internString("S"));
 		DSymbol* b = pair.symbol.getFirstPartNamed(internString("b"));
 		assert(S);
+		assert(b);
+		assert(b.type);
 		assert(b.type.type is S);
 	}
 	{
@@ -359,6 +365,8 @@ unittest
 		DSymbol* S = pair.symbol.getFirstPartNamed(internString("S"));
 		DSymbol* b = pair.symbol.getFirstPartNamed(internString("b"));
 		assert(S);
+		assert(b);
+		assert(b.type);
 		assert(b.type.name == ARRAY_SYMBOL_NAME);
 		assert(b.type.type is S);
 	}
@@ -368,6 +376,7 @@ unittest
 		DSymbol* S = pair.symbol.getFirstPartNamed(internString("S"));
 		DSymbol* b = pair.symbol.getFirstPartNamed(internString("b"));
 		assert(S);
+		assert(b);
 		assert(b.type is S);
 	}
 }
@@ -639,7 +648,7 @@ ScopeSymbolPair generateAutocompleteTrees(string source, string filename, ref Mo
 
 
 	secondPass(first.rootSymbol, first.moduleScope, cache);
-	thirdPass(first.moduleScope, cache, cursorPosition);
+	thirdPass(first.rootSymbol, first.moduleScope, cache, cursorPosition);
 	auto ufcsSymbols = getUFCSSymbolsForCursor(first.moduleScope, tokens, cursorPosition);
 	auto r = first.rootSymbol.acSymbol;
 	typeid(SemanticSymbol).destroy(first.rootSymbol);
@@ -658,7 +667,10 @@ ScopeSymbolPair generateAutocompleteTreesProd(string source, string filename, si
 
 version (linux)
 {
-	enum string ufcsExampleCode =
+
+	unittest
+	{
+		enum string ufcsExampleCode =
 q{class Incrementer
 {
 	int run(int x)
@@ -676,9 +688,6 @@ void doIncrement()
 	life.
 }};
 
-	unittest
-	{
-		import dsymbol.ufcs;
 
 		writeln("Getting UFCS Symbols For life");
 		ModuleCache cache;
@@ -701,9 +710,18 @@ void doIncrement()
 	life.
 }};
 
-unittest
+	unittest
 	{
-		import dsymbol.ufcs;
+		enum string ufcsTemplateExampleCode =
+q{int increment(T)(T x)
+{
+	return x++;
+}
+void doIncrement()
+{
+	int life = 42;
+	life.
+}};
 
 		writeln("Getting Templated UFCS Symbols For life");
 		ModuleCache cache;
@@ -715,4 +733,22 @@ unittest
 
 	}
 
+	unittest
+	{
+		enum string ufcsPointerExampleCode =
+q{void increment(int* x) { }
+void doIncrement(int* x, int* y)
+{
+	y.
+}};
+
+		writeln("Getting Ptr UFCS completion");
+		ModuleCache cache;
+		// position of variable life
+		size_t cursorPos = 65;
+		auto pair = generateAutocompleteTreesProd(ufcsPointerExampleCode, randomDFilename, cursorPos, cache);
+		assert(pair.ufcsSymbols[0].name == "increment");
+		assert(pair.ufcsSymbols[1].name == "doIncrement");
+	}
+
 }

dsymbol/src/dsymbol/type_lookup.d

@@ -10,7 +10,6 @@ enum TypeLookupKind : ubyte
 {
 	inherit,
 	aliasThis,
-	initializer,
 	mixinTemplate,
 	varOrFunType,
 	selectiveImport,

dsymbol/src/dsymbol/ufcs.d

@@ -21,16 +21,18 @@ enum CompletionContext
     ParenCompletion,
 }
 
+
 struct TokenCursorResult
 {
     CompletionContext completionContext;
     istring functionName;
-    istring symbolIdentifierName;
+    Token significantToken;
+    string partialIdentifier;
 }
 
 // https://dlang.org/spec/type.html#implicit-conversions
 enum string[string] INTEGER_PROMOTIONS = [
-        "bool": "int",
+        "bool": "byte",
         "byte": "int",
         "ubyte": "int",
         "short": "int",
@@ -38,25 +40,49 @@ enum string[string] INTEGER_PROMOTIONS = [
         "char": "int",
         "wchar": "int",
         "dchar": "uint",
+
+        // found in test case extra/tc_ufcs_all_kinds:
+        "int": "float",
+        "uint": "float",
+        "long": "float",
+        "ulong": "float",
+
+        "float": "double",
+        "double": "real",
     ];
 
-enum MAX_RECURSION_DEPTH = 50;
+enum MAX_NUMBER_OF_MATCHING_RUNS = 50;
 
-private DSymbol* deduceSymbolType(DSymbol* symbol)
+private const(DSymbol)* deduceSymbolTypeByToken(Scope* completionScope, scope ref const(Token) significantToken, size_t cursorPosition)
 {
-    DSymbol* symbolType = symbol.type;
+    //Literal type deduction
+    if (significantToken.type is tok!"stringLiteral"){
+        return completionScope.getFirstSymbolByNameAndCursor(symbolNameToTypeName(STRING_LITERAL_SYMBOL_NAME), cursorPosition);
+    }
+
+    const(DSymbol)* symbol = completionScope.getFirstSymbolByNameAndCursor(istring(significantToken.text), cursorPosition);
+
+    if (symbol is null) {
+        return null;
+    }
+
+    const(DSymbol)* symbolType = symbol.type;
     while (symbolType !is null && (symbolType.qualifier == SymbolQualifier.func
             || symbolType.kind == CompletionKind.functionName
             || symbolType.kind == CompletionKind.importSymbol
             || symbolType.kind == CompletionKind.aliasName))
     {
-        if (symbolType.type is null || symbolType.type is symbolType)
+        if (symbolType.type is null
+            || symbolType.type is symbolType
+            || symbolType.name.data == "string") // special case for string
         {
             break;
         }
         //look at next type to deduce
         symbolType = symbolType.type;
     }
+
+
     return symbolType;
 
 }
@@ -81,16 +107,29 @@ private TokenCursorResult getCursorToken(const(Token)[] tokens, size_t cursorPos
         return tokenCursorResult;
     }
 
-    if (sortedBeforeTokens.length >= 2 
+    // move before identifier for
+    if (sortedBeforeTokens[$ - 1].type is tok!"identifier")
+    {
+        tokenCursorResult.partialIdentifier = sortedBeforeTokens[$ - 1].text;
+        sortedBeforeTokens = sortedBeforeTokens[0 .. $ - 1];
+    }
+
+    if (sortedBeforeTokens.length >= 2
         && sortedBeforeTokens[$ - 1].type is tok!"."
-        && sortedBeforeTokens[$ - 2].type is tok!"identifier")
+        && (sortedBeforeTokens[$ - 2].type is tok!"identifier" || sortedBeforeTokens[$ - 2].type is tok!"stringLiteral"))
     {
         // Check if it's UFCS dot completion
+        auto expressionTokens = getExpression(sortedBeforeTokens);
+        if(expressionTokens[0] !is sortedBeforeTokens[$ - 2]){
+            // If the expression is invalid as a dot token we return
+            return tokenCursorResult;
+        }
+
+        tokenCursorResult.significantToken = sortedBeforeTokens[$ - 2];
         tokenCursorResult.completionContext = CompletionContext.DotCompletion;
-        tokenCursorResult.symbolIdentifierName = istring(sortedBeforeTokens[$ - 2].text);
         return tokenCursorResult;
     }
-    else
+    else if (!tokenCursorResult.partialIdentifier.length)
     {
         // Check if it's UFCS paren completion
         size_t index = goBackToOpenParen(sortedBeforeTokens);
@@ -108,7 +147,7 @@ private TokenCursorResult getCursorToken(const(Token)[] tokens, size_t cursorPos
             && slicedAtParen[$ - 1].type is tok!"(")
         {
             tokenCursorResult.completionContext = CompletionContext.ParenCompletion;
-            tokenCursorResult.symbolIdentifierName = istring(slicedAtParen[$ - 4].text);
+            tokenCursorResult.significantToken = slicedAtParen[$ - 4];
             tokenCursorResult.functionName = istring(slicedAtParen[$ - 2].text);
             return tokenCursorResult;
         }
@@ -118,7 +157,7 @@ private TokenCursorResult getCursorToken(const(Token)[] tokens, size_t cursorPos
     return tokenCursorResult;
 }
 
-private void getUFCSSymbols(T, Y)(ref T localAppender, ref Y globalAppender, Scope* completionScope, size_t cursorPosition)
+private void getUFCSSymbols(T, Y)(scope ref T localAppender, scope ref Y globalAppender, Scope* completionScope, size_t cursorPosition)
 {
 
     Scope* currentScope = completionScope.getScopeByCursor(cursorPosition);
@@ -168,11 +207,8 @@ private void getUFCSSymbols(T, Y)(ref T localAppender, ref Y globalAppender, Sco
     }
 }
 
-DSymbol*[] getUFCSSymbolsForCursor(Scope* completionScope, ref const(Token)[] tokens, size_t cursorPosition)
+DSymbol*[] getUFCSSymbolsForCursor(Scope* completionScope, scope ref const(Token)[] tokens, size_t cursorPosition)
 {
-    DSymbol* cursorSymbol;
-    DSymbol* cursorSymbolType;
-
     TokenCursorResult tokenCursorResult = getCursorToken(tokens, cursorPosition);
 
     if (tokenCursorResult.completionContext is CompletionContext.UnknownCompletion)
@@ -181,29 +217,14 @@ DSymbol*[] getUFCSSymbolsForCursor(Scope* completionScope, ref const(Token)[] to
         return [];
     }
 
-    cursorSymbol = completionScope.getFirstSymbolByNameAndCursor(
-        tokenCursorResult.symbolIdentifierName, cursorPosition);
+    const(DSymbol)* deducedSymbolType = deduceSymbolTypeByToken(completionScope, tokenCursorResult.significantToken, cursorPosition);
 
-    if (cursorSymbol is null)
-    {
-        warning("Coudn't find symbol ", tokenCursorResult.symbolIdentifierName);
-        return [];
-    }
-
-    if (cursorSymbol.isInvalidForUFCSCompletion)
-    {
-        trace("CursorSymbol is invalid for UFCS");
-        return [];
-    }
-
-    cursorSymbolType = deduceSymbolType(cursorSymbol);
-
-    if (cursorSymbolType is null)
+    if (deducedSymbolType is null)
     {
         return [];
     }
 
-    if (cursorSymbolType.isInvalidForUFCSCompletion)
+    if (deducedSymbolType.isInvalidForUFCSCompletion)
     {
         trace("CursorSymbolType isn't valid for UFCS completion");
         return [];
@@ -211,28 +232,34 @@ DSymbol*[] getUFCSSymbolsForCursor(Scope* completionScope, ref const(Token)[] to
 
     if (tokenCursorResult.completionContext == CompletionContext.ParenCompletion)
     {
-        return getUFCSSymbolsForParenCompletion(cursorSymbolType, completionScope, tokenCursorResult.functionName, cursorPosition);
+        return getUFCSSymbolsForParenCompletion(deducedSymbolType, completionScope, tokenCursorResult.functionName, cursorPosition);
     }
     else
     {
-        return getUFCSSymbolsForDotCompletion(cursorSymbolType, completionScope, cursorPosition);
+        return getUFCSSymbolsForDotCompletion(deducedSymbolType, completionScope, cursorPosition, tokenCursorResult.partialIdentifier);
     }
 
 }
 
-private DSymbol*[] getUFCSSymbolsForDotCompletion(DSymbol* symbolType, Scope* completionScope, size_t cursorPosition)
+private DSymbol*[] getUFCSSymbolsForDotCompletion(const(DSymbol)* symbolType, Scope* completionScope, size_t cursorPosition, string partial)
 {
     // local appender
-    FilteredAppender!(a => a.isCallableWithArg(symbolType), DSymbol*[]) localAppender;
+    FilteredAppender!((DSymbol* a) =>
+            a.isCallableWithArg(symbolType)
+            && toUpper(a.name.data).startsWith(toUpper(partial)),
+        DSymbol*[]) localAppender;
     // global appender
-    FilteredAppender!(a => a.isCallableWithArg(symbolType, true), DSymbol*[]) globalAppender;
+    FilteredAppender!((DSymbol* a) =>
+            a.isCallableWithArg(symbolType, true)
+            && toUpper(a.name.data).startsWith(toUpper(partial)),
+        DSymbol*[]) globalAppender;
 
     getUFCSSymbols(localAppender, globalAppender, completionScope, cursorPosition);
 
     return localAppender.data ~ globalAppender.data;
 }
 
-private DSymbol*[] getUFCSSymbolsForParenCompletion(DSymbol* symbolType, Scope* completionScope, istring searchWord, size_t cursorPosition)
+private DSymbol*[] getUFCSSymbolsForParenCompletion(const(DSymbol)* symbolType, Scope* completionScope, istring searchWord, size_t cursorPosition)
 {
     // local appender
     FilteredAppender!(a => a.isCallableWithArg(symbolType) && a.name.among(searchWord), DSymbol*[]) localAppender;
@@ -245,42 +272,124 @@ private DSymbol*[] getUFCSSymbolsForParenCompletion(DSymbol* symbolType, Scope*
 
 }
 
-private bool willImplicitBeUpcasted(const(DSymbol)* from, const(DSymbol)* to)
+private bool willImplicitBeUpcasted(scope ref const(DSymbol) incomingSymbolType, scope ref const(DSymbol) significantSymbolType)
 {
-    if (from is null || to is null || to.functionParameters.empty || to.functionParameters.front.type is null) {
-        return false;
-    }
-
-    string fromTypeName = from.name.data;
-    string toTypeName = to.functionParameters.front.type.name.data;
+    string fromTypeName = significantSymbolType.name.data;
+    string toTypeName = incomingSymbolType.name.data;
 
     return typeWillBeUpcastedTo(fromTypeName, toTypeName);
 }
 
-private bool typeWillBeUpcastedTo(string from, string to) {
-    if (auto promotionType = from in INTEGER_PROMOTIONS)
-        return *promotionType == to;
+private bool typeWillBeUpcastedTo(string from, string to)
+{
+    while (true)
+    {
+        if (typeWillIntegerUpcastedTo(from, to))
+            return true;
+        if (from.typeIsFloating && to.typeIsFloating)
+            return true;
 
-    return false;
+        if (auto promotionType = from in INTEGER_PROMOTIONS)
+        {
+            if (*promotionType == to)
+                return true;
+            from = *promotionType;
+        }
+        else
+            return false;
+    }
 }
 
-private bool matchAliasThis(const(DSymbol)* beforeDotType, const(DSymbol)* incomingSymbol, int recursionDepth)
+private bool typeWillIntegerUpcastedTo(string from, string to)
 {
-    // For now we are only resolving the first alias this symbol
-    // when multiple alias this are supported, we can rethink another solution
-    if (beforeDotType.aliasThisSymbols.empty || beforeDotType.aliasThisSymbols.front == beforeDotType)
+    int fromIntSize = getIntegerTypeSize(from);
+    int toIntSize = getIntegerTypeSize(to);
+    return fromIntSize != 0 && toIntSize != 0 && fromIntSize <= toIntSize;
+}
+
+private int getIntegerTypeSize(string type)
+{
+    switch (type)
     {
+    // ordered by subjective frequency of use, since the compiler may use that
+    // for optimization.
+    case "int", "uint": return 4;
+    case "long", "ulong": return 8;
+    case "byte", "ubyte": return 1;
+    case "short", "ushort": return 2;
+    case "dchar": return 4;
+    case "wchar": return 2;
+    case "char": return 1;
+    default: return 0;
+    }
+}
+
+private bool typeIsFloating(string type)
+{
+    switch (type)
+    {
+    case "float":
+    case "double":
+    case "real":
+        return true;
+    default:
         return false;
     }
-
-    //Incrementing depth count to ensure we don't run into an infinite loop
-    recursionDepth++;
-
-    return isCallableWithArg(incomingSymbol, beforeDotType.aliasThisSymbols.front.type, false, recursionDepth);
 }
 
-bool isNonConstrainedTemplate(const(DSymbol)* incomingSymbol){
-    return incomingSymbol.functionParameters.front.type !is null && incomingSymbol.functionParameters.front.type.kind is CompletionKind.typeTmpParam; 
+bool isNonConstrainedTemplate(scope ref const(DSymbol) symbolType)
+{
+    return symbolType.kind is CompletionKind.typeTmpParam;
+}
+
+private bool matchesWithTypeOfPointer(scope ref const(DSymbol) incomingSymbolType, scope ref const(DSymbol) significantSymbolType)
+{
+    return incomingSymbolType.qualifier == SymbolQualifier.pointer
+        && significantSymbolType.qualifier == SymbolQualifier.pointer
+        && incomingSymbolType.type is significantSymbolType.type;
+}
+
+private bool matchesWithTypeOfArray(scope ref const(DSymbol) incomingSymbolType, scope ref const(DSymbol) cursorSymbolType)
+{
+    return incomingSymbolType.qualifier == SymbolQualifier.array
+        && cursorSymbolType.qualifier == SymbolQualifier.array
+        && incomingSymbolType.type is cursorSymbolType.type;
+
+}
+
+private bool typeMatchesWith(scope ref const(DSymbol) incomingSymbolType, scope ref const(DSymbol) significantSymbolType) {
+    return incomingSymbolType is significantSymbolType
+        || isNonConstrainedTemplate(incomingSymbolType)
+        || matchesWithTypeOfArray(incomingSymbolType, significantSymbolType)
+        || matchesWithTypeOfPointer(incomingSymbolType, significantSymbolType);
+}
+
+private bool matchSymbolType(const(DSymbol)* firstParameter, const(DSymbol)* significantSymbolType) {
+
+    auto currentSignificantSymbolType = significantSymbolType;
+    uint numberOfRetries = 0;
+
+    do
+    {
+        if (typeMatchesWith(*firstParameter.type, *currentSignificantSymbolType)) {
+            return true;
+        }
+
+        if (!(firstParameter.parameterIsRef || firstParameter.parameterIsOut)
+            && willImplicitBeUpcasted(*firstParameter.type, *currentSignificantSymbolType))
+            return true;
+
+        if (currentSignificantSymbolType.aliasThisSymbols.empty || currentSignificantSymbolType is currentSignificantSymbolType.aliasThisSymbols.front){
+            return false;
+        }
+
+        numberOfRetries++;
+        // For now we are only resolving the first alias this symbol
+        // when multiple alias this are supported, we can rethink another solution
+        currentSignificantSymbolType = currentSignificantSymbolType.aliasThisSymbols.front.type;
+    }
+    while(numberOfRetries <= MAX_NUMBER_OF_MATCHING_RUNS);
+    return false;
 }
 
 /**
@@ -292,23 +401,18 @@ bool isNonConstrainedTemplate(const(DSymbol)* incomingSymbol){
  *     `true` if `incomingSymbols`' first parameter matches `beforeDotType`
  *     `false` otherwise
  */
-bool isCallableWithArg(const(DSymbol)* incomingSymbol, const(DSymbol)* beforeDotType, bool isGlobalScope = false, int recursionDepth = 0)
+bool isCallableWithArg(const(DSymbol)* incomingSymbol, const(DSymbol)* beforeDotType, bool isGlobalScope = false)
 {
-    if (incomingSymbol is null 
+    if (incomingSymbol is null
         || beforeDotType is null
-        || isGlobalScope && incomingSymbol.protection is tok!"private" // don't show private functions if we are in global scope
-        || recursionDepth > MAX_RECURSION_DEPTH)
+        || isGlobalScope && incomingSymbol.protection is tok!"private") // don't show private functions if we are in global scope
     {
         return false;
     }
 
     if (incomingSymbol.kind is CompletionKind.functionName && !incomingSymbol.functionParameters.empty && incomingSymbol.functionParameters.front.type)
     {
-        return beforeDotType is incomingSymbol.functionParameters.front.type
-            || isNonConstrainedTemplate(incomingSymbol)
-            || willImplicitBeUpcasted(beforeDotType, incomingSymbol)
-            || matchAliasThis(beforeDotType, incomingSymbol, recursionDepth);
-
+        return matchSymbolType(incomingSymbol.functionParameters.front, beforeDotType);
     }
     return false;
 }

dsymbol/src/dsymbol/utils.d

@@ -153,3 +153,91 @@ unittest
 	i = skipParenReverseBefore(t, i, tok!")", tok!"(");
 	assert(i == 1);
 }
+
+T getExpression(T)(T beforeTokens)
+{
+	enum EXPRESSION_LOOP_BREAK = q{
+		if (i + 1 < beforeTokens.length) switch (beforeTokens[i + 1].type)
+		{
+		mixin (TYPE_IDENT_AND_LITERAL_CASES);
+			i++;
+			break expressionLoop;
+		default:
+			break;
+		}
+	};
+
+	if (beforeTokens.length == 0)
+		return beforeTokens[0 .. 0];
+	size_t i = beforeTokens.length - 1;
+	size_t sliceEnd = beforeTokens.length;
+	IdType open;
+	IdType close;
+	uint skipCount = 0;
+
+	expressionLoop: while (true)
+	{
+		switch (beforeTokens[i].type)
+		{
+		case tok!"import":
+			i++;
+			break expressionLoop;
+		mixin (TYPE_IDENT_AND_LITERAL_CASES);
+			mixin (EXPRESSION_LOOP_BREAK);
+			break;
+		case tok!".":
+			break;
+		case tok!")":
+			open = tok!")";
+			close = tok!"(";
+			goto skip;
+		case tok!"]":
+			open = tok!"]";
+			close = tok!"[";
+		skip:
+			mixin (EXPRESSION_LOOP_BREAK);
+			immutable bookmark = i;
+			i = beforeTokens.skipParenReverse(i, open, close);
+
+			skipCount++;
+
+			// check the current token after skipping parens to the left.
+			// if it's a loop keyword, pretend we never skipped the parens.
+			if (i > 0) switch (beforeTokens[i - 1].type)
+			{
+				case tok!"scope":
+				case tok!"if":
+				case tok!"while":
+				case tok!"for":
+				case tok!"foreach":
+				case tok!"foreach_reverse":
+				case tok!"do":
+				case tok!"cast":
+				case tok!"catch":
+					i = bookmark + 1;
+					break expressionLoop;
+				case tok!"!":
+					// only break if the bang is for a template instance
+					if (i - 2 >= 0  && beforeTokens[i - 2].type == tok!"identifier" && skipCount == 1)
+					{
+						sliceEnd = i - 1;
+						i -= 2;
+						break expressionLoop;
+					}
+					break;
+				default:
+					break;
+			}
+			break;
+		default:
+			i++;
+			break expressionLoop;
+		}
+		if (i == 0)
+			break;
+		else
+			i--;
+	}
+	return beforeTokens[i .. sliceEnd];
+}
+

dub.json

@@ -8,7 +8,7 @@
   "license": "GPL-3.0",
   "dependencies": {
     ":dsymbol": "*",
-    "libdparse": ">=0.20.0 <0.23.0",
+    "libdparse": ">=0.23.0 <0.26.0",
     ":common": "*",
     "emsi_containers": "~>0.9.0"
   },

dub.selections.json

@@ -3,8 +3,8 @@
 	"versions": {
 		"dsymbol": "0.14.1",
 		"emsi_containers": "0.9.0",
-		"libdparse": "0.22.0",
-		"msgpack-d": "1.0.4",
+		"libdparse": "0.25.0",
+		"msgpack-d": "1.0.5",
 		"stdx-allocator": "2.77.5"
 	}
 }

libdparse

@@ -1 +1 @@
-Subproject commit 98bf0f4166578717e0b78472ff5054d6f918e797
+Subproject commit f8a6c28589aae180532fb460a1b22e92a0978292

makefile

@@ -13,8 +13,6 @@ LDC := ldc2
 DPARSE_DIR := libdparse
 DSYMBOL_DIR := dsymbol
 
-SHELL:=/bin/bash
-
 githash:
 	@mkdir -p bin
 	git describe --tags > bin/githash.txt
@@ -37,7 +35,6 @@ CLIENT_SRC := \
 DMD_CLIENT_FLAGS := -Imsgpack-d/src\
 	-Imsgpack-d/src\
 	-Jbin\
-	-inline\
 	-O\
 	-wi\
 	-ofbin/dcd-client
@@ -56,6 +53,10 @@ LDC_CLIENT_FLAGS := -Imsgpack-d/src\
 	-oq\
 	-of=bin/dcd-client
 
+ifneq ($(shell uname), OpenBSD)
+	override DMD_CLIENT_FLAGS += -inline
+endif
+
 override DMD_CLIENT_FLAGS += $(DFLAGS)
 override LDC_CLIENT_FLAGS += $(DFLAGS)
 override GDC_CLIENT_FLAGS += $(DFLAGS)
@@ -76,7 +77,6 @@ DMD_SERVER_FLAGS := -Icontainers/src\
 	-wi\
 	-O\
 	-release\
-	-inline\
 	-ofbin/dcd-server
 
 DEBUG_SERVER_FLAGS := -Icontainers/src\
@@ -106,6 +106,10 @@ LDC_SERVER_FLAGS := -Icontainers/src\
 	-O5\
 	-release
 
+ifneq ($(shell uname), OpenBSD)
+	DMD_SERVER_FLAGS += -inline
+endif
+
 override DMD_SERVER_FLAGS += $(DFLAGS)
 override LDC_SERVER_FLAGS += $(DFLAGS)
 override GDC_SERVER_FLAGS += $(DFLAGS)
@@ -137,7 +141,7 @@ ldcserver: githash
 	${LDC} $(LDC_SERVER_FLAGS) ${SERVER_SRC} -oq -of=bin/dcd-server
 
 test: debugserver dmdclient
-	cd tests && ./run_tests.sh
+	cd tests && ./run_tests.sh --extra
 
 release:
 	./release.sh

msgpack-d

@@ -1 +1 @@
-Subproject commit 480f3bf9ee80ccf6695ed900cfcc1850ba8da991
+Subproject commit 26ef07e16023483ad93e3f86374b19d0e541c924

src/dcd/client/client.d

@@ -62,6 +62,7 @@ int runClient(string[] args)
 	bool clearCache;
 	bool symbolLocation;
 	bool doc;
+	bool inlayHints;
 	bool query;
 	bool printVersion;
 	bool listImports;
@@ -86,6 +87,7 @@ int runClient(string[] args)
 			"R", &removedImportPaths, "port|p", &port, "help|h", &help,
 			"shutdown", &shutdown, "clearCache", &clearCache,
 			"symbolLocation|l", &symbolLocation, "doc|d", &doc,
+			"inlayHints", &inlayHints,
 			"query|status|q", &query, "search|s", &search,
 			"version", &printVersion, "listImports", &listImports,
 			"tcp", &useTCP, "socketFile", &socketFile,
@@ -181,7 +183,7 @@ int runClient(string[] args)
 		printImportList(response);
 		return 0;
 	}
-	else if (search == null && cursorPos == size_t.max)
+	else if (search == null && !inlayHints && cursorPos == size_t.max)
 	{
 		// cursor position is a required argument
 		printHelp(args[0]);
@@ -234,6 +236,8 @@ int runClient(string[] args)
 		request.kind |= RequestKind.search;
 	else if(localUse)
 		request.kind |= RequestKind.localUse;
+    else if (inlayHints)
+		request.kind |= RequestKind.inlayHints;
 	else
 		request.kind |= RequestKind.autocomplete;
 
@@ -250,11 +254,13 @@ int runClient(string[] args)
 	else if (getIdentifier)
 		printIdentifierResponse(response);
 	else if (doc)
-		printDocResponse(response);
+		printDocResponse(response, fullOutput);
 	else if (search !is null)
 		printSearchResponse(response);
 	else if (localUse)
 		printLocalUse(response);
+	else if (inlayHints)
+		printInlayHintsResponse(response);
 	else
 		printCompletionResponse(response, fullOutput);
 
@@ -295,6 +301,10 @@ Options:
         Gets documentation comments associated with the symbol at the cursor
         location.
 
+    --inlayHints
+        For all supported variable usages, show value types. Currently shows
+        alias definitions.
+
     --search | -s symbolName
         Searches for symbolName in both stdin / the given file name as well as
         others files cached by the server.
@@ -359,10 +369,14 @@ Socket createSocket(string socketFile, ushort port)
 	return socket;
 }
 
-void printDocResponse(ref const AutocompleteResponse response)
+void printDocResponse(ref const AutocompleteResponse response, bool extended)
 {
-	import std.algorithm : each;
-	response.completions.each!(a => a.documentation.escapeConsoleOutputString(true).writeln);
+	foreach (ref completion; response.completions)
+	{
+		if (extended)
+			writeln(completion.definition);
+		writeln(completion.documentation.escapeConsoleOutputString(true));
+	}
 }
 
 void printIdentifierResponse(ref const AutocompleteResponse response)
@@ -380,6 +394,21 @@ void printLocationResponse(ref const AutocompleteResponse response)
 		writeln(makeTabSeparated(response.symbolFilePath, response.symbolLocation.to!string));
 }
 
+void printInlayHintsResponse(ref const AutocompleteResponse response)
+{
+	auto app = appender!(string[])();
+	foreach (ref completion; response.completions)
+	{
+		app.put(makeTabSeparated(
+			completion.kind == char.init ? "" : "" ~ completion.kind,
+			completion.identifier,
+			completion.symbolLocation.to!string
+		));
+	}
+	foreach (line; app.data)
+		writeln(line);
+}
+
 void printCompletionResponse(ref const AutocompleteResponse response, bool extended)
 {
 	if (response.completions.length > 0)

src/dcd/server/autocomplete/complete.d

@@ -28,6 +28,7 @@ import std.path;
 import std.range : assumeSorted;
 import std.string;
 import std.typecons;
+import std.exception : enforce;
 
 import dcd.server.autocomplete.util;
 
@@ -47,6 +48,13 @@ import dsymbol.utils;
 import dcd.common.constants;
 import dcd.common.messages;
 
+enum CalltipHint {
+	none, // asserts false if passed into setCompletion with CompletionType.calltips
+	regularArguments,
+	templateArguments,
+	indexOperator,
+}
+
 /**
  * Handles autocompletion
  * Params:
@@ -128,29 +136,28 @@ public AutocompleteResponse complete(const AutocompleteRequest request,
 		}
 	}
 
-	if (beforeTokens.length >= 2)
-	{
-		if (beforeTokens[$ - 1] == tok!"(" || beforeTokens[$ - 1] == tok!"["
-			|| beforeTokens[$ - 1] == tok!",")
-		{
-			immutable size_t end = goBackToOpenParen(beforeTokens);
-			if (end != size_t.max)
-				return parenCompletion(beforeTokens[0 .. end], tokenArray,
-					request.cursorPosition, moduleCache);
+	size_t parenIndex;
+	auto calltipHint = getCalltipHint(beforeTokens, parenIndex);
+
+	final switch (calltipHint) with (CalltipHint) {
+	case regularArguments, templateArguments, indexOperator:
+		return calltipCompletion(beforeTokens[0 .. parenIndex], tokenArray,
+			request.cursorPosition, moduleCache, calltipHint);
+	case none:
+		// could be import or dot completion
+		if (beforeTokens.length < 2){
+			break;
 		}
-		else
+
+		ImportKind kind = determineImportKind(beforeTokens);
+		if (kind == ImportKind.neither)
 		{
-			ImportKind kind = determineImportKind(beforeTokens);
-			if (kind == ImportKind.neither)
-			{
-				if (beforeTokens.isUdaExpression)
-					beforeTokens = beforeTokens[$-1 .. $];
-				return dotCompletion(beforeTokens, tokenArray, request.cursorPosition,
-					moduleCache);
-			}
-			else
-				return importCompletion(beforeTokens, kind, moduleCache);
+			if (beforeTokens.isUdaExpression)
+				beforeTokens = beforeTokens[$ - 1 .. $];
+			return dotCompletion(beforeTokens, tokenArray, request.cursorPosition,
+				moduleCache);
 		}
+		return importCompletion(beforeTokens, kind, moduleCache);
 	}
 	return dotCompletion(beforeTokens, tokenArray, request.cursorPosition, moduleCache);
 }
@@ -205,14 +212,12 @@ AutocompleteResponse dotCompletion(T)(T beforeTokens, const(Token)[] tokenArray,
 		significantTokenType = beforeTokens[$ - 2].type;
 	else
 		return response;
-
 	switch (significantTokenType)
 	{
 	mixin(STRING_LITERAL_CASES);
 		foreach (symbol; arraySymbols)
 			response.completions ~= makeSymbolCompletionInfo(symbol, symbol.kind);
-		response.completionType = CompletionType.identifiers;
-		break;
+		goto case;
 	mixin(TYPE_IDENT_CASES);
 	case tok!")":
 	case tok!"]":
@@ -220,8 +225,12 @@ AutocompleteResponse dotCompletion(T)(T beforeTokens, const(Token)[] tokenArray,
 		ScopeSymbolPair pair = generateAutocompleteTrees(tokenArray, &rba, cursorPosition, moduleCache);
 		scope(exit) pair.destroy();
 		response.setCompletions(pair.scope_, getExpression(beforeTokens),
-			cursorPosition, CompletionType.identifiers, false, partial);
-		response.completions ~= pair.ufcsSymbols.map!(s => makeSymbolCompletionInfo(s, CompletionKind.ufcsName)).array;
+			cursorPosition, CompletionType.identifiers, CalltipHint.none, partial);
+		if (!pair.ufcsSymbols.empty) {
+			response.completions ~= pair.ufcsSymbols.map!(s => makeSymbolCompletionInfo(s, CompletionKind.ufcsName)).array;
+			// Setting CompletionType in case of none symbols are found via setCompletions, but we have UFCS symbols.
+			response.completionType = CompletionType.identifiers;
+		}
 		break;
 	//  these tokens before a "." mean "Module Scope Operator"
 	case tok!":":
@@ -235,7 +244,7 @@ AutocompleteResponse dotCompletion(T)(T beforeTokens, const(Token)[] tokenArray,
 		ScopeSymbolPair pair = generateAutocompleteTrees(tokenArray, &rba, 1, moduleCache);
 		scope(exit) pair.destroy();
 		response.setCompletions(pair.scope_, getExpression(beforeTokens),
-			1, CompletionType.identifiers, false, partial);
+			1, CompletionType.identifiers, CalltipHint.none, partial);
 		break;
 	default:
 		break;
@@ -243,8 +252,9 @@ AutocompleteResponse dotCompletion(T)(T beforeTokens, const(Token)[] tokenArray,
 	return response;
 }
 
+deprecated("Use `calltipCompletion` instead") alias parenCompletion = calltipCompletion;
 /**
- * Handles paren completion for function calls and some keywords
+ * Handles calltip completion for function calls and some keywords
  * Params:
  *     beforeTokens = the tokens before the cursor
  *     tokenArray = all tokens in the file
@@ -252,12 +262,15 @@ AutocompleteResponse dotCompletion(T)(T beforeTokens, const(Token)[] tokenArray,
  * Returns:
  *     the autocompletion response
  */
-AutocompleteResponse parenCompletion(T)(T beforeTokens,
-	const(Token)[] tokenArray, size_t cursorPosition, ref ModuleCache moduleCache)
+AutocompleteResponse calltipCompletion(T)(T beforeTokens,
+	const(Token)[] tokenArray, size_t cursorPosition, ref ModuleCache moduleCache,
+	CalltipHint calltipHint = CalltipHint.none)
 {
 	AutocompleteResponse response;
 	immutable(ConstantCompletion)[] completions;
-	switch (beforeTokens[$ - 2].type)
+	auto significantTokenId = getSignificantTokenId(beforeTokens);
+
+	switch (significantTokenId)
 	{
 	case tok!"__traits":
 		completions = traits;
@@ -305,9 +318,11 @@ AutocompleteResponse parenCompletion(T)(T beforeTokens,
 		RollbackAllocator rba;
 		ScopeSymbolPair pair = generateAutocompleteTrees(tokenArray, &rba, cursorPosition, moduleCache);
 		scope(exit) pair.destroy();
-		auto expression = getExpression(beforeTokens[0 .. $ - 1]);
+		// We remove by 2 when the calltip hint is !( else remove by 1.
+		auto endOffset = beforeTokens.isTemplateBangParen ? 2 : 1;
+		auto expression = getExpression(beforeTokens[0 .. $ - endOffset]);
 		response.setCompletions(pair.scope_, expression,
-			cursorPosition, CompletionType.calltips, beforeTokens[$ - 1] == tok!"[");
+			cursorPosition, CompletionType.calltips, calltipHint);
 		if (!pair.ufcsSymbols.empty) {
 			response.completions ~= pair.ufcsSymbols.map!(s => makeSymbolCompletionInfo(s, CompletionKind.ufcsName)).array;
 			// Setting CompletionType in case of none symbols are found via setCompletions, but we have UFCS symbols.
@@ -320,6 +335,68 @@ AutocompleteResponse parenCompletion(T)(T beforeTokens,
 	return response;
 }
 
+IdType getSignificantTokenId(T)(T beforeTokens)
+{
+	auto significantTokenId = beforeTokens[$ - 2].type;
+	if (beforeTokens.isTemplateBangParen)
+	{
+		return beforeTokens[$ - 3].type;
+	}
+	return significantTokenId;
+}
+/**
+ * Hinting what the user expects for calltip completion
+ * Params:
+ *   beforeTokens = tokens before the cursor
+ * Returns: calltipHint based of beforeTokens
+ */
+CalltipHint getCalltipHint(T)(T beforeTokens, out size_t parenIndex)
+{
+	if (beforeTokens.length < 2)
+	{
+		return CalltipHint.none;
+	}
+
+	parenIndex = beforeTokens.length;
+	// evaluate at comma case
+	if (beforeTokens.isComma)
+	{
+		size_t tmp = beforeTokens.goBackToOpenParen;
+		if(tmp == size_t.max){
+			return CalltipHint.regularArguments;
+		}
+		parenIndex = tmp;
+
+		// check if we are actually a "!("
+		if (beforeTokens[0 .. parenIndex].isTemplateBangParen)
+		{
+			return CalltipHint.templateArguments;
+		}
+		else if (beforeTokens[0 .. parenIndex].isIndexOperator)
+		{
+			// we are inside `a[foo, bar]`, which is definitely a custom opIndex
+			return CalltipHint.indexOperator;
+		}
+		return CalltipHint.regularArguments;
+	}
+
+	if (beforeTokens.isIndexOperator)
+	{
+		return CalltipHint.indexOperator;
+	}
+	else if (beforeTokens.isTemplateBang || beforeTokens.isTemplateBangParen)
+	{
+		return CalltipHint.templateArguments;
+	}
+	else if (beforeTokens.isOpenParen || beforeTokens.isOpenSquareBracket)
+	{
+		// open square bracket for literals: `foo([`
+		return CalltipHint.regularArguments;
+	}
+
+	return CalltipHint.none;
+}
+
 /**
  * Provides autocomplete for selective imports, e.g.:
  * ---
@@ -503,7 +580,8 @@ void setImportCompletions(T)(T tokens, ref AutocompleteResponse response,
  */
 void setCompletions(T)(ref AutocompleteResponse response,
 	Scope* completionScope, T tokens, size_t cursorPosition,
-	CompletionType completionType, bool isBracket = false, string partial = null)
+	CompletionType completionType, CalltipHint callTipHint = CalltipHint.none,
+	string partial = null)
 {
 	static void addSymToResponse(const(DSymbol)* s, ref AutocompleteResponse r, string p,
 		Scope* completionScope, size_t[] circularGuard = [])
@@ -565,6 +643,14 @@ void setCompletions(T)(ref AutocompleteResponse response,
 	DSymbol*[] symbols = getSymbolsByTokenChain(completionScope, tokens,
 		cursorPosition, completionType);
 
+	// If calltipHint is templateArguments we ensure that the symbol is also templated
+	if (callTipHint == CalltipHint.templateArguments
+		&& symbols.length >= 1
+		&& symbols[0].qualifier != SymbolQualifier.templated)
+	{
+		return;
+	}
+
 	if (symbols.length == 0)
 		return;
 
@@ -585,6 +671,7 @@ void setCompletions(T)(ref AutocompleteResponse response,
 	}
 	else if (completionType == CompletionType.calltips)
 	{
+		enforce(callTipHint != CalltipHint.none, "Make sure to have a properly defined calltipHint!");
 		//trace("Showing call tips for ", symbols[0].name, " of kind ", symbols[0].kind);
 		if (symbols[0].kind != CompletionKind.functionName
 			&& symbols[0].callTip is null)
@@ -605,7 +692,7 @@ void setCompletions(T)(ref AutocompleteResponse response,
 						symbols = [dumb];
 						goto setCallTips;
 					}
-					if (isBracket)
+					if (callTipHint == CalltipHint.indexOperator)
 					{
 						auto index = dumb.getPartsByName(internString("opIndex"));
 						if (index.length > 0)
@@ -625,6 +712,14 @@ void setCompletions(T)(ref AutocompleteResponse response,
 			if (symbols[0].kind == CompletionKind.structName
 				|| symbols[0].kind == CompletionKind.className)
 			{
+				if (callTipHint == CalltipHint.templateArguments)
+				{
+					response.completionType = CompletionType.calltips;
+					response.completions = [generateStructConstructorCalltip(symbols[0], callTipHint)];
+					return;
+				}
+
+				//Else we do calltip for regular arguments
 				auto constructor = symbols[0].getPartsByName(CONSTRUCTOR_SYMBOL_NAME);
 				if (constructor.length == 0)
 				{
@@ -632,7 +727,7 @@ void setCompletions(T)(ref AutocompleteResponse response,
 					if (symbols[0].kind == CompletionKind.structName)
 					{
 						response.completionType = CompletionType.calltips;
-						response.completions = [generateStructConstructorCalltip(symbols[0])];
+						response.completions = [generateStructConstructorCalltip(symbols[0], callTipHint)];
 						return;
 					}
 				}
@@ -672,23 +767,30 @@ bool mightBeRelevantInCompletionScope(const DSymbol* symbol, Scope* scope_)
 }
 
 
-AutocompleteResponse.Completion generateStructConstructorCalltip(const DSymbol* symbol)
+AutocompleteResponse.Completion generateStructConstructorCalltip(
+	const DSymbol* symbol,
+	CalltipHint calltipHint = CalltipHint.regularArguments
+)
 in
 {
-	assert(symbol.kind == CompletionKind.structName);
+	if (calltipHint == CalltipHint.regularArguments)
+	{
+		assert(symbol.kind == CompletionKind.structName);
+	}
 }
 do
 {
-	string generatedStructConstructorCalltip = "this(";
-	const(DSymbol)*[] fields = symbol.opSlice().filter!(
-		a => a.kind == CompletionKind.variableName).map!(a => cast(const(DSymbol)*) a).array();
+	string generatedStructConstructorCalltip = calltipHint == CalltipHint.regularArguments ? "this(" : symbol.name ~ "!(";
+	auto completionKindFilter = calltipHint == CalltipHint.regularArguments ? CompletionKind.variableName : CompletionKind.typeTmpParam;
+	const(DSymbol)*[] fields =
+	symbol.opSlice().filter!(a => a.kind == completionKindFilter).map!(a => cast(const(DSymbol)*) a).array();
 	fields.sort!((a, b) => a.location < b.location);
 	foreach (i, field; fields)
 	{
-		if (field.kind != CompletionKind.variableName)
+		if (field.kind != completionKindFilter)
 			continue;
 		i++;
-		if (field.type !is null)
+		if (field.type !is null && calltipHint == CalltipHint.regularArguments)
 		{
 			generatedStructConstructorCalltip ~= field.type.name;
 			generatedStructConstructorCalltip ~= " ";
@@ -699,7 +801,7 @@ do
 	}
 	generatedStructConstructorCalltip ~= ")";
 	auto completion = makeSymbolCompletionInfo(symbol, char.init);
-	completion.identifier = "this";
+	completion.identifier = calltipHint == CalltipHint.regularArguments ? "this" : symbol.name;
 	completion.definition = generatedStructConstructorCalltip;
 	completion.typeOf = symbol.name;
 	return completion;

src/dcd/server/autocomplete/doc.d

@@ -62,7 +62,7 @@ public AutocompleteResponse getDoc(const AutocompleteRequest request,
 				continue;
 			firstSymbol = false;
 
-			AutocompleteResponse.Completion c;
+			AutocompleteResponse.Completion c = makeSymbolCompletionInfo(symbol, symbol.kind);
 			c.documentation = symbol.doc;
 			response.completions ~= c;
 		}

src/dcd/server/autocomplete/inlayhints.d

@@ -0,0 +1,111 @@
+/**
+ * This file is part of DCD, a development tool for the D programming language.
+ * Copyright (C) 2014 Brian Schott
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+module dcd.server.autocomplete.inlayhints;
+
+import std.stdio;
+import std.algorithm;
+import std.array;
+import std.experimental.allocator;
+import std.experimental.logger;
+import std.typecons;
+
+import dcd.server.autocomplete.util;
+
+import dparse.lexer;
+import dparse.rollback_allocator;
+
+import dsymbol.modulecache;
+import dsymbol.symbol;
+import dsymbol.scope_;
+import dsymbol.conversion;
+import dsymbol.string_interning;
+
+import dcd.common.messages;
+
+import containers.hashset;
+
+public AutocompleteResponse getInlayHints(const AutocompleteRequest request,
+	ref ModuleCache moduleCache)
+{
+//	trace("Getting inlay hints comments");
+	AutocompleteResponse response;
+
+	LexerConfig config;
+	config.fileName = "";
+	auto cache = StringCache(request.sourceCode.length.optimalBucketCount);
+	auto tokenArray = getTokensForParser(cast(ubyte[]) request.sourceCode, config, &cache);
+	RollbackAllocator rba;
+	auto pair = generateAutocompleteTrees(tokenArray, &rba, -1, moduleCache);
+	scope(exit) pair.destroy();
+
+	void check(DSymbol* it, ref HashSet!size_t visited)
+	{
+		if (visited.contains(cast(size_t) it))
+			return;
+		if (it.symbolFile != "stdin") return;
+		visited.insert(cast(size_t) it);
+
+		//writeln("sym: ", it.name," ", it.location, " kind: ", it.kind," qualifier: ", it.qualifier);
+		//if (auto type = it.type)
+		//{
+		//	writeln("   ", type.name, " kind: ", type.kind, " qualifier", type.qualifier);
+		//	if (auto ttype = type.type)
+		//		writeln("      ", ttype.name, " kind: ", ttype.kind, " qualifier", ttype.qualifier);
+		//}
+
+
+		// aliases
+		// 		struct Data {}
+		// 		alias Alias1 = Data;
+		// 		Alias1 var;				becomes:  Alias1 [-> Data] var;
+		if (it.kind == CompletionKind.variableName && it.type && it.type.kind == CompletionKind.aliasName)
+		{
+			AutocompleteResponse.Completion c;
+			c.symbolLocation = it.location - 1;
+			c.kind = CompletionKind.aliasName;
+
+			DSymbol* type = it.type;
+
+			while (type)
+			{
+				if (type.kind == CompletionKind.aliasName && type.type)
+					c.identifier ~= "->" ~ type.type.name;
+				if (type.type && type.type.kind != CompletionKind.aliasName) break;
+				type = type.type;
+			}
+
+			response.completions ~= c;
+		}
+
+		foreach(part; it.opSlice())
+			check(part, visited);
+	}
+
+	HashSet!size_t visited;
+	foreach (symbol; pair.scope_.symbols)
+	{
+		check(symbol, visited);
+		foreach(part; symbol.opSlice())
+			check(part, visited);
+	}
+
+	response.completions.sort!"a.symbolLocation < b.symbolLocation";
+
+	return response;
+}

src/dcd/server/autocomplete/localuse.d

@@ -31,6 +31,7 @@ import dparse.rollback_allocator;
 import dsymbol.conversion;
 import dsymbol.modulecache;
 import dsymbol.symbol;
+import dsymbol.utils;
 
 import dcd.common.messages;
 
@@ -56,12 +57,14 @@ public AutocompleteResponse findLocalUse(AutocompleteRequest request,
 	config.fileName = "";
 	const(Token)[] tokenArray = getTokensForParser(cast(ubyte[]) request.sourceCode,
 			config, &cache);
+	auto sortedTokens = assumeSorted(tokenArray);
+	ScopeSymbolPair pair = generateAutocompleteTrees(tokenArray,
+		&rba, request.cursorPosition, moduleCache);
+	scope(exit) pair.destroy();
+
 	SymbolStuff getSymbolsAtCursor(size_t cursorPosition)
 	{
-		auto sortedTokens = assumeSorted(tokenArray);
 		auto beforeTokens = sortedTokens.lowerBound(cursorPosition);
-		ScopeSymbolPair pair = generateAutocompleteTrees(tokenArray,
-			&rba, request.cursorPosition, moduleCache);
 		auto expression = getExpression(beforeTokens);
 		return SymbolStuff(getSymbolsByTokenChain(pair.scope_, expression,
 			cursorPosition, CompletionType.location), pair.symbol, pair.scope_);
@@ -69,7 +72,6 @@ public AutocompleteResponse findLocalUse(AutocompleteRequest request,
 
 	// gets the symbol matching to cursor pos
 	SymbolStuff stuff = getSymbolsAtCursor(cast(size_t)request.cursorPosition);
-	scope(exit) stuff.destroy();
 
 	// starts searching only if no ambiguity with the symbol
 	if (stuff.symbols.length == 1)
@@ -99,7 +101,6 @@ public AutocompleteResponse findLocalUse(AutocompleteRequest request,
 			{
 				size_t pos = cast(size_t) t.index + 1; // place cursor inside the token
 				SymbolStuff candidate = getSymbolsAtCursor(pos);
-				scope(exit) candidate.destroy();
 				if (candidate.symbols.length == 1 &&
 					candidate.symbols[0].location == sourceSymbol.location &&
 					candidate.symbols[0].symbolFile == sourceSymbol.symbolFile)

src/dcd/server/autocomplete/package.d

@@ -24,3 +24,4 @@ import dcd.server.autocomplete.complete;
 import dcd.server.autocomplete.doc;
 import dcd.server.autocomplete.localuse;
 import dcd.server.autocomplete.symbols;
+import dcd.server.autocomplete.inlayhints;

src/dcd/server/autocomplete/util.d

@@ -147,7 +147,8 @@ SymbolStuff getSymbolsForCompletion(const AutocompleteRequest request,
 	auto expression = getExpression(beforeTokens);
 	auto symbols = getSymbolsByTokenChain(pair.scope_, expression,
 		request.cursorPosition, type);
-	if (symbols.length == 0 && doUFCSSearch(stringToken(beforeTokens.front), stringToken(beforeTokens.back))) {
+	if (symbols.length == 0 && !beforeTokens.empty &&
+		doUFCSSearch(stringToken(beforeTokens.front), stringToken(beforeTokens.back))) {
 		// Let search for UFCS, since we got no hit
 		symbols ~= getSymbolsByTokenChain(pair.scope_, getExpression([beforeTokens.back]), request.cursorPosition, type);
 	}
@@ -422,96 +423,6 @@ DSymbol*[] getSymbolsByTokenChain(T)(Scope* completionScope,
 	return symbols;
 }
 
-/**
- *
- */
-T getExpression(T)(T beforeTokens)
-{
-	enum EXPRESSION_LOOP_BREAK = q{
-		if (i + 1 < beforeTokens.length) switch (beforeTokens[i + 1].type)
-		{
-		mixin (TYPE_IDENT_AND_LITERAL_CASES);
-			i++;
-			break expressionLoop;
-		default:
-			break;
-		}
-	};
-
-	if (beforeTokens.length == 0)
-		return beforeTokens[0 .. 0];
-	size_t i = beforeTokens.length - 1;
-	size_t sliceEnd = beforeTokens.length;
-	IdType open;
-	IdType close;
-	uint skipCount = 0;
-
-	expressionLoop: while (true)
-	{
-		switch (beforeTokens[i].type)
-		{
-		case tok!"import":
-			i++;
-			break expressionLoop;
-		mixin (TYPE_IDENT_AND_LITERAL_CASES);
-			mixin (EXPRESSION_LOOP_BREAK);
-			break;
-		case tok!".":
-			break;
-		case tok!")":
-			open = tok!")";
-			close = tok!"(";
-			goto skip;
-		case tok!"]":
-			open = tok!"]";
-			close = tok!"[";
-		skip:
-			mixin (EXPRESSION_LOOP_BREAK);
-			immutable bookmark = i;
-			i = beforeTokens.skipParenReverse(i, open, close);
-
-			skipCount++;
-
-			// check the current token after skipping parens to the left.
-			// if it's a loop keyword, pretend we never skipped the parens.
-			if (i > 0) switch (beforeTokens[i - 1].type)
-			{
-				case tok!"scope":
-				case tok!"if":
-				case tok!"while":
-				case tok!"for":
-				case tok!"foreach":
-				case tok!"foreach_reverse":
-				case tok!"do":
-				case tok!"cast":
-				case tok!"catch":
-					i = bookmark + 1;
-					break expressionLoop;
-				case tok!"!":
-					// only break if the bang is for a template instance
-					if (i - 2 >= 0  && beforeTokens[i - 2].type == tok!"identifier" && skipCount == 1)
-					{
-						sliceEnd = i - 1;
-						i -= 2;
-						break expressionLoop;
-					}
-					break;
-				default:
-					break;
-			}
-			break;
-		default:
-			i++;
-			break expressionLoop;
-		}
-		if (i == 0)
-			break;
-		else
-			i--;
-	}
-	return beforeTokens[i .. sliceEnd];
-}
-
 /**
  * Determines if an import is selective, whole-module, or neither.
  */
@@ -636,8 +547,43 @@ AutocompleteResponse.Completion makeSymbolCompletionInfo(const DSymbol* symbol,
 	return ret;
 }
 
-bool doUFCSSearch(string beforeToken, string lastToken)
+bool doUFCSSearch(string beforeToken, string lastToken) pure
 {
     // we do the search if they are different from eachother
     return beforeToken != lastToken;
 }
+
+// Check if we are doing an index operation calltip hint
+package bool isIndexOperator(T)(T beforeTokens) pure {
+	return beforeTokens.length >= 2 && beforeTokens[$ - 2] == tok!"identifier" && beforeTokens[$ - 1] == tok!"[";
+}
+
+// Check if we are doing "," calltip hint
+package bool isComma(T)(T beforeTokens) pure {
+	return beforeTokens.length >= 1 && beforeTokens[$ - 1] == tok!",";
+}
+
+// Check if we are doing "[" calltip hint
+package bool isOpenSquareBracket(T)(T beforeTokens) pure {
+	return beforeTokens.length >= 1 && beforeTokens[$ - 1] == tok!"[";
+}
+
+// Check if we are doing "(" calltip hint
+package bool isOpenParen(T)(T beforeTokens) pure {
+	return beforeTokens.length >= 1 && beforeTokens[$ - 1] == tok!"(";
+}
+
+// Check if we are doing a single "!" calltip hint
+package bool isTemplateBang(T)(T beforeTokens) pure {
+	return beforeTokens.length >= 2
+		&& beforeTokens[$ - 2] == tok!"identifier"
+		&& beforeTokens[$ - 1] == tok!"!";
+}
+
+// Check if we are doing "!(" calltip hint
+package bool isTemplateBangParen(T)(T beforeTokens) pure {
+	return beforeTokens.length >= 3
+		&& beforeTokens[$ - 3] == tok!"identifier"
+		&& beforeTokens[$ - 2] == tok!"!"
+		&& beforeTokens[$ - 1] == tok!"(";
+}

src/dcd/server/main.d

@@ -26,7 +26,6 @@ import std.datetime.stopwatch : AutoStart, StopWatch;
 import std.exception : enforce;
 import std.experimental.allocator;
 import std.experimental.allocator.mallocator;
-import std.experimental.logger;
 import std.file;
 import std.getopt;
 import std.path: buildPath;
@@ -34,6 +33,11 @@ import std.process;
 import std.socket;
 import std.stdio;
 
+static if (__VERSION__ >= 2_101)
+	import std.logger;
+else
+	import std.experimental.logger;
+
 import msgpack;
 
 import dcd.common.dcd_version;
@@ -45,6 +49,15 @@ import dcd.server.server;
 
 int main(string[] args)
 {
+	version (D_ProfileGC)
+	{
+		import core.runtime;
+
+		// make sure profilegc.log is written to cwd and not to `/`
+		// (since we `chdir` to `/` later)
+		profilegc_setlogfilename(buildPath(getcwd, "profilegc.log"));
+	}
+
 	try
 	{
 		return runServer(args);
@@ -63,7 +76,7 @@ int runServer(string[] args)
 	bool printVersion;
 	bool ignoreConfig;
 	string[] importPaths;
-	LogLevel level = globalLogLevel;
+	LogLevel level = LogLevel.info;
 	version(Windows)
 	{
 		bool useTCP = true;
@@ -90,7 +103,10 @@ int runServer(string[] args)
 		return 1;
 	}
 
-	globalLogLevel = level;
+	static if (__VERSION__ >= 2_101)
+		(cast()sharedLog).logLevel = level;
+	else
+		globalLogLevel = level;
 
 	if (printVersion)
 	{
@@ -331,6 +347,11 @@ int runServer(string[] args)
 				s.trySendResponse(symbolSearch(request, cache), "Could not perform symbol search");
 			else if (request.kind & RequestKind.localUse)
 				s.trySendResponse(findLocalUse(request, cache), "Couldnot find local usage");
+			else if (request.kind & RequestKind.inlayHints)
+			{
+				info("Getting inlay hints");
+				s.trySendResponse(getInlayHints(request, cache), "Could not get inlay hints");
+			}
 			else if (needResponse)
 				s.trySendResponse(AutocompleteResponse.ack, "Could not send ack");
 		}

src/dcd/server/server.d

@@ -35,6 +35,9 @@ enum CONFIG_FILE_NAME = "dcd.conf";
 version(linux) version = useXDG;
 version(BSD) version = useXDG;
 version(FreeBSD) version = useXDG;
+version(OpenBSD) version = useXDG;
+version(NetBSD) version = useXDG;
+version(DragonflyBSD) version = useXDG;
 version(OSX) version = useXDG;
 
 /**

tests/extra/tc_ufcs_all_kinds/.gitignore

@@ -0,0 +1 @@
+proc_test.d

tests/extra/tc_ufcs_all_kinds/generate_tests.d

@@ -0,0 +1,266 @@
+// This generates functions with all specified test types as first argument +
+// variables for each specified test type.
+// Then it calls all functions with every type to see which ones are accepted by
+// the compiler, to automatically stay up-to-date.
+
+import std;
+import fs = std.file;
+
+string[] testTypes = [
+	"bool",
+	"byte",
+	"ubyte",
+	"short",
+	"ushort",
+	"int",
+	"uint",
+	"long",
+	"ulong",
+	"char",
+	"wchar",
+	"dchar",
+	"float",
+	"double",
+	"real",
+	"BasicStruct",
+	"AliasThisInt",
+];
+// index here must map onto varTypePermutations index
+string[][] funcTypePermutations = [
+	// TODO: check for const/inout/immutable/shared in UFCS checks
+	[
+		"%s",
+		// "const(%s)",
+		"ref %s",
+		// "ref const(%s)"
+	],
+	[
+		"%s*",
+		// "const(%s)*",
+		// "const(%s*)",
+		"ref %s*",
+		// "ref const(%s)*",
+		// "ref const(%s*)"
+	],
+	[
+		"%s[]",
+		// "const(%s)[]",
+		// "const(%s[])",
+		"ref %s[]",
+		// "ref const(%s)[]",
+		// "ref const(%s[])"
+	]
+];
+string[][] varTypePermutations = [
+	[
+		"%s",
+		// "const(%s)"
+	],
+	[
+		"%s*",
+		// "const(%s)*",
+		// "const(%s*)"
+	],
+	[
+		"%s[]",
+		// "const(%s)[]",
+		// "const(%s[])"
+	]
+];
+
+string preamble = `
+struct BasicStruct { int member1; string member2; }
+struct AliasThisInt { int member1; string member2; alias member1 this; }
+
+`;
+
+int main(string[] args)
+{
+	string functionsCode;
+	string varsCode;
+	string callCode;
+
+	string[] allFunctions;
+	string[string] funcLookup;
+	string[string] varLookup;
+
+	foreach (ti, type; testTypes)
+	{
+		foreach (pi, perms; funcTypePermutations)
+		{
+			foreach (i, perm; perms)
+			{
+				string resolved = format(perm, type);
+				string id = getID(ti, pi, i);
+				allFunctions ~= ("func_" ~ id);
+				functionsCode ~= "void func_" ~ id ~ "(" ~ resolved ~ " arg) {}\n";
+				functionsCode ~= resolved ~ " make_" ~ id ~ "() { static " ~ resolved
+					.chompPrefix("ref ") ~ " x; return x; }\n";
+				funcLookup["func_" ~ id] = resolved;
+			}
+		}
+		foreach (pi, perms; varTypePermutations)
+		{
+			foreach (i, perm; perms)
+			{
+				string resolved = format(perm, type);
+				string id = getID(ti, pi, i);
+				varsCode ~= resolved ~ " var_" ~ id ~ " = make_" ~ id ~ "();\n";
+				varLookup["var_" ~ id] = resolved;
+				foreach (cti, subType; testTypes)
+					foreach (ci, subPerms; funcTypePermutations)
+						foreach (fi, subPerm; subPerms)
+						{
+							callCode ~= "var_" ~ id ~ ".func_" ~ getID(cti, ci, fi) ~ "();\n";
+						}
+			}
+		}
+	}
+
+	allFunctions.sort!"a<b";
+
+	string code = preamble
+		~ functionsCode
+		~ "\nvoid main() {\n"
+		~ varsCode
+		~ callCode
+		~ "}\n";
+	string[] lines = code.splitLines;
+
+	fs.write("proc_test.d", code);
+
+	auto output = executeShell("$DC -verrors=0 -c proc_test.d").output;
+
+	size_t numErrors = 0;
+
+	string[][string] variableIncompatibilities;
+
+	foreach (err; output.lineSplitter)
+	{
+		if (!err.startsWith("proc_test.d("))
+			continue;
+		err = err["proc_test.d(".length .. $];
+		auto lineNo = err.parse!int;
+		if (!err.startsWith("): Error: "))
+			continue;
+		err = err["): Error: ".length .. $];
+		string line = lines[lineNo - 1];
+		enforce(line.endsWith("();"), "Unexpected error in line " ~ lineNo.to!string);
+		line = line[0 .. $ - 3];
+		string varName = line.findSplit(".")[0];
+		string funcName = line.findSplit(".")[2];
+		// writeln("variable type ", varLookup[varName], " can't call ", funcLookup[funcName]);
+		variableIncompatibilities[varName] ~= funcName;
+		numErrors++;
+	}
+
+	enforce(numErrors > 1_000, "compiler didn't error as expected, need to adjust tests!");
+
+	writeln("Total incompatible type combinations: ", numErrors);
+
+	string[][string] wrongDCDCompletions;
+
+	foreach (varName; varLookup.byKey)
+	{
+		string input = code[0 .. $ - 2]
+			~ "\n"
+			~ varName ~ ".func_";
+
+		string[] dcdClient = ["../../../bin/dcd-client"];
+		if (args[1].length)
+			dcdClient ~= args[1];
+
+		auto proc = pipeProcess(dcdClient ~ ["-c" ~ to!string(input.length)]);
+		proc.stdin.rawWrite(input);
+		proc.stdin.rawWrite("\n}\n");
+		proc.stdin.close();
+
+		string[] dcdResult;
+
+		size_t i = 0;
+		foreach (line; proc.stdout.byLineCopy)
+		{
+			if (i++ == 0)
+			{
+				enforce(line == "identifiers");
+				continue;
+			}
+
+			auto parts = line.split("\t");
+			if (parts[1] != "F")
+				continue;
+			dcdResult ~= parts[0];
+		}
+
+		enforce(i > 0, "every variable must auto-complete something! Missing completion for var " ~ varName
+				~ " of type " ~ varLookup[varName] ~ generateEmptyResponseReproductionCode(
+					varLookup[varName]));
+		enforce(dcdResult.length > 0, "Wrongly no UFCS completion for var " ~ varName
+				~ " of type " ~ varLookup[varName] ~ generateEmptyResponseReproductionCode(
+					varLookup[varName]));
+
+		dcdResult.sort!"a<b";
+
+		string[] minusExpect = variableIncompatibilities[varName];
+		minusExpect.sort!"a<b";
+		variableIncompatibilities[varName] = minusExpect = minusExpect.uniq.array;
+
+		auto neededFunctions = setDifference(allFunctions, minusExpect);
+
+		auto unneccessaryFunctions = setDifference(dcdResult, neededFunctions);
+		auto missingFunctions = setDifference(neededFunctions, setIntersection(
+				dcdResult, neededFunctions));
+
+		string[] diff =
+			unneccessaryFunctions.map!(ln => '+' ~ ln)
+				.chain(missingFunctions.map!(ln => '-' ~ ln))
+				.array;
+
+		// writeln(varLookup[varName], " -> ", dcdResult);
+		if (diff.length)
+			wrongDCDCompletions[varName] = diff;
+	}
+
+	foreach (varName, wrongTypes; wrongDCDCompletions)
+	{
+		writeln("Incorrect results for ", varLookup[varName], ":");
+		wrongTypes.sort!"a<b";
+		char prevChar = ' ';
+		foreach (wrongType; wrongTypes)
+		{
+			if (prevChar != wrongType[0])
+			{
+				prevChar = wrongType[0];
+				if (prevChar == '+')
+					writeln("\tDCD errornously matched these argument types:");
+				else if (prevChar == '-')
+					writeln("\tDCD errornously did not match these argument types:");
+			}
+
+			wrongType = wrongType[1 .. $];
+			writeln("\t\t", funcLookup[wrongType]);
+		}
+		writeln();
+	}
+
+	return wrongDCDCompletions.length ? 1 : 0;
+}
+
+string getID(size_t ti, size_t pi, size_t i)
+{
+	return format!"%s_%s_%s"(ti, pi, i);
+}
+
+string generateEmptyResponseReproductionCode(string type)
+{
+	string prefix =
+		"void ufcsFunc(" ~ type ~ " v) {}\n\n"
+		~ "void main() {\n"
+		~ "    " ~ type ~ " myVar;\n"
+		~ "    myVar.ufcs";
+	return "\n\nReproduction code:\n```d\n"
+		~ prefix ~ ";\n"
+		~ "}\n"
+		~ "```\n\n"
+		~ "call `dcd-client -c" ~ prefix.length.to!string ~ "`";
+}

tests/extra/tc_ufcs_all_kinds/run.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+if [ -z "${DC:-}" ]; then
+	DC=dmd
+fi
+
+DC="$DC" "$DC" -run generate_tests.d "$1"

tests/run_tests.sh

@@ -1,10 +1,48 @@
-#! /bin/bash
+#! /usr/bin/env bash
 RED="\033[31m"
 GREEN="\033[32m"
 YELLOW="\033[33m"
 NORMAL="\033[0m"
 IMPORTS=$(pwd)/imports
 export IMPORTS
+SOCKETMODES="unix tcp"
+TIME_SERVER=0
+REUSE_SERVER=0
+EXTRA_ARGS=
+EXTRA_TESTCASES=
+
+# `--arguments` must come before test dirs!
+while (( "$#" )); do
+	if [[ "$1" == "--tcp-only" ]]; then
+		# only test TCP sockets
+		SOCKETMODES="tcp"
+	elif [[ "$1" == "--unix-only" ]]; then
+		# only test unix domain sockets
+		SOCKETMODES="unix"
+	elif [[ "$1" == "--reuse-server" ]]; then
+		# reuse existing dcd-server (for example when debugging it)
+		REUSE_SERVER=1
+	elif [[ "$1" == "--time-server" ]]; then
+		# --time-server runs dcd-server through /usr/bin/time, for statistics
+		# implies `--unix-only` (since we only want a single mode to time)
+		# socket mode can still be overriden with `--tcp-only`
+		TIME_SERVER=1
+		SOCKETMODES="unix"
+	elif [[ "$1" == "--extra" ]]; then
+		# also include tests in the "extra" directory that long to complete
+		EXTRA_TESTCASES="extra/*/"
+	elif [[ "$1" == "--verbose" ]]; then
+		# also include tests in the "extra" directory that long to complete
+		EXTRA_ARGS="--logLevel=trace"
+	elif [[ "$1" =~ ^-- ]]; then
+		echo "Unrecognized test argument: $1"
+		exit 1
+	else
+		break
+	fi
+
+	shift
+done
 
 if [ -z "${1:-}" ];
 then
@@ -18,22 +56,52 @@ pass_count=0
 client="../bin/dcd-client"
 server="../bin/dcd-server"
 tcp=""
+server_pid=""
 
 function startServer()
 {
-	"$server" "$tcp" --ignoreConfig -I $IMPORTS 2>stderr.txt > stdout.txt &
-	server_pid=$!
+	if [[ "$REUSE_SERVER" == "1" ]]; then
+		echo "Not starting server, since user wants to reuse existing server"
+	elif [[ "$TIME_SERVER" == "1" ]]; then
+		/usr/bin/time -v "$server" "$tcp" --ignoreConfig $EXTRA_ARGS -I $IMPORTS 2>stderr.txt > stdout.txt &
+		server_pid=$!
+	else
+		"$server" "$tcp" --ignoreConfig $EXTRA_ARGS -I $IMPORTS 2>stderr.txt > stdout.txt &
+		server_pid=$!
+	fi
 	sleep 1
 }
 
-# Make sure that the server is shut down
-echo "Shutting down currently-running server..."
-"$client" --shutdown 2>/dev/null > /dev/null
-"$client" --shutdown --tcp 2>/dev/null > /dev/null
+function waitShutdown()
+{
+	if [[ -z "$server_pid" ]]; then
+		sleep 0.5 # not owned by us
+	else
+		( sleep 15 ; echo 'Waiting for shutdown timed out'; kill $server_pid ) &
+		killerPid=$!
 
-for socket in unix tcp; do
+		wait $server_pid
+		status=$?
+		(kill -0 $killerPid && kill $killerPid) || true
+
+		server_pid=""
+
+		return $status
+	fi
+}
+
+# Make sure that the server is shut down
+if [[ "$REUSE_SERVER" == "1" ]]; then
+	echo "Not shutting down existing server due to --reuse-server"
+else
+	echo "Shutting down currently-running server..."
+	"$client" --shutdown 2>/dev/null > /dev/null
+	"$client" --shutdown --tcp 2>/dev/null > /dev/null
+fi
+
+for socket in $SOCKETMODES; do # supported: unix tcp
 	# allow some time for server to shutdown
-	sleep 0.5;
+	waitShutdown
 
 	if [[ $socket == "tcp" ]]; then
 		tcp="--tcp"
@@ -58,7 +126,7 @@ for socket in unix tcp; do
 	done
 
 	# Run tests
-	for testCase in $TESTCASES; do
+	for testCase in $TESTCASES $EXTRA_TESTCASES; do
 		cd $testCase
 
 		./run.sh "$tcp"
@@ -88,6 +156,8 @@ for socket in unix tcp; do
 	echo "Shutting down server..."
 	"$client" --shutdown "$tcp" 2>/dev/null > /dev/null
 
+	waitShutdown
+
 	# Report
 	if [[ $fail_count -eq 0 ]]; then
 		echo -e "${GREEN}${pass_count} tests passed and ${fail_count} failed.${NORMAL}"

tests/tc717/expected.txt

@@ -0,0 +1,8 @@
+identifiers
+alignof	k				
+init	k				int
+mangleof	k				
+max	k				int
+min	k				int
+sizeof	k				
+stringof	k				

tests/tc717/file.d

@@ -0,0 +1,15 @@
+struct A
+{
+    B b;
+
+    void test()
+    {
+        auto here = b.inside_b;
+        here.
+    }
+}
+
+struct B
+{
+    int inside_b;
+}

tests/tc717/run.sh

@@ -0,0 +1,5 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d --extended -c88 > actual.txt
+diff actual.txt expected.txt --strip-trailing-cr

tests/tc_casts/expected1.txt

@@ -0,0 +1,8 @@
+identifiers
+alignof	k
+init	k
+inside_c	v
+mangleof	k
+sizeof	k
+stringof	k
+tupleof	k

tests/tc_casts/file.d

@@ -0,0 +1,34 @@
+struct A
+{
+	struct B
+	{
+		struct C
+		{
+			int inside_c;
+		}
+		int inside_b;
+	}
+	int inside_a;
+}
+
+unittest
+{
+	auto from_cast = cast(A.B.C) nonExist;
+	from_cast.
+}
+
+unittest
+{
+	struct A {}
+
+	auto from_cast = cast(A.B.C) nonExist;
+	from_cast.
+}
+
+unittest
+{
+	struct A {}
+
+	auto from_cast = cast(.A.B.C) nonExist;
+	from_cast.
+}

tests/tc_casts/run.sh

@@ -0,0 +1,11 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d -c159 > actual1.txt
+diff actual1.txt expected1.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c239 > actual2.txt
+diff actual2.txt expected2.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c320 > actual3.txt
+diff actual3.txt expected1.txt --strip-trailing-cr

tests/tc_ctors/expected.txt

@@ -0,0 +1,3 @@
+identifiers
+mangleof	k
+member1	v

tests/tc_ctors/file.d

@@ -0,0 +1,19 @@
+struct Foo {
+	this(int mCtor) {}
+	int member1;
+}
+
+class Bar {
+	this(int mCtor) {}
+	int member1;
+}
+
+unittest {
+	Foo f;
+	f.m
+}
+
+unittest {
+	Bar b = new Bar(1);
+	b.m
+}

tests/tc_ctors/run.sh

@@ -0,0 +1,8 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d -c122 > actual.txt
+diff actual.txt expected.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c162 > actual.txt
+diff actual.txt expected.txt --strip-trailing-cr

tests/tc_inlay_hints/expected.txt

@@ -0,0 +1,2 @@
+l	->Point	208
+l	->Point	247

tests/tc_inlay_hints/file.d

@@ -0,0 +1,17 @@
+// when extending the inlayHints capabilities, don't forget to update the --help
+// text inside client.d
+
+import point;
+import point : P = Point;
+
+void foo(int x, int y) {}
+void foo(Point point) {}
+void bar(P point, int z = 1) {}
+
+void main()
+{
+	P p;
+	foo(1, 2);
+	foo(p);
+	bar(p, 3);
+}

tests/tc_inlay_hints/run.sh

@@ -0,0 +1,5 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 --inlayHints file.d > actual.txt
+diff actual.txt expected.txt --strip-trailing-cr

tests/tc_template_bang_completion/expected.txt

@@ -0,0 +1,2 @@
+calltips
+Wrapper!(T)

tests/tc_template_bang_completion/expected2.txt

@@ -0,0 +1,2 @@
+calltips
+Something!(T, X)

tests/tc_template_bang_completion/expected3.txt

@@ -0,0 +1,2 @@
+calltips
+void doSomething(T)(T someElement)

tests/tc_template_bang_completion/expected4.txt

@@ -0,0 +1,2 @@
+calltips
+void doSomething(T)(T someElement)

tests/tc_template_bang_completion/expected5.txt

@@ -0,0 +1,2 @@
+calltips
+void doSomething(T)(T someElement)

tests/tc_template_bang_completion/expected6.txt

@@ -0,0 +1,2 @@
+calltips
+Something!(T, X)

tests/tc_template_bang_completion/file.d

@@ -0,0 +1,43 @@
+struct Wrapper(T) {
+	T data;
+}
+
+class Something(T, X){
+	this(T foo, X bar){}
+}
+
+void doSomething(T)(T someElement){
+
+}
+
+void instantiateTemp1() {
+	Wrapper!
+}
+
+void instantiateTemp2() {
+	Something!
+}
+
+void instantiateTemp3() {
+	doSomething!
+}
+
+void instantiateTemp4() {
+	doSomething!(
+}
+
+void instantiateTemp5() {
+	doSomething!("something",
+}
+
+void instantiateTemp6() {
+	Something!("something",
+}
+
+void shouldNotComplete1() {
+	Something!!
+}
+
+void shouldNotComplete2() {
+	Something!!(
+}

tests/tc_template_bang_completion/run.sh

@@ -0,0 +1,26 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d -c155 > actual.txt
+diff actual.txt expected.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c196 > actual2.txt
+diff actual2.txt expected2.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c239 > actual3.txt
+diff actual3.txt expected3.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c283 > actual4.txt
+diff actual4.txt expected4.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c339 > actual5.txt
+diff actual5.txt expected5.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c393 > actual6.txt
+diff actual6.txt expected6.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c437 > actual7.txt
+diff actual7.txt expected7.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 file.d -c482 > actual8.txt
+diff actual8.txt expected8.txt --strip-trailing-cr

tests/tc_traits/expected.txt

@@ -1,13 +1,17 @@
 identifiers
 allMembers	k
+child	k
+classInstanceAlignment	k
 classInstanceSize	k
 compiles	k
 derivedMembers	k
 getAliasThis	k
 getAttributes	k
+getCppNamespaces	k
 getFunctionAttributes	k
 getFunctionVariadicStyle	k
 getLinkage	k
+getLocation	k
 getMember	k
 getOverloads	k
 getParameterStorageClasses	k
@@ -18,12 +22,17 @@ getUnitTests	k
 getVirtualFunctions	k
 getVirtualIndex	k
 getVirtualMethods	k
+getVisibility	k
+hasCopyConstructor	k
 hasMember	k
+hasPostblit	k
 identifier	k
+initSymbol	k
 isAbstractClass	k
 isAbstractFunction	k
 isArithmetic	k
 isAssociativeArray	k
+isCopyable	k
 isDeprecated	k
 isDisabled	k
 isFinalClass	k
@@ -32,10 +41,12 @@ isFloating	k
 isFuture	k
 isIntegral	k
 isLazy	k
+isModule	k
 isNested	k
 isOut	k
 isOverrideFunction	k
 isPOD	k
+isPackage	k
 isRef	k
 isReturnOnStack	k
 isSame	k
@@ -47,4 +58,6 @@ isUnsigned	k
 isVirtualFunction	k
 isVirtualMethod	k
 isZeroInit	k
+parameters	k
 parent	k
+toType	k

tests/tc_typeof/expected1.txt

@@ -0,0 +1,20 @@
+identifiers
+getMember	f	typeof(member) getMember()	stdin 78		Result
+identifiers
+staticMember	f	typeof(S.member) staticMember()	stdin 133		Result
+identifiers
+alignof	k				
+expected	v	int expected	stdin 21		int
+init	k				
+mangleof	k				
+sizeof	k				
+stringof	k				
+tupleof	k				
+identifiers
+alignof	k				
+expected	v	int expected	stdin 21		int
+init	k				
+mangleof	k				
+sizeof	k				
+stringof	k				
+tupleof	k				

tests/tc_typeof/expected2.txt

@@ -0,0 +1,2 @@
+identifiers
+test	v	Enum test	stdin 121		Enum

tests/tc_typeof/expected3.txt

@@ -0,0 +1,8 @@
+identifiers
+alignof	k				
+init	k				
+mangleof	k				
+ok	v	bool ok	stdin 16		bool
+sizeof	k				
+stringof	k				
+tupleof	k				

tests/tc_typeof/run.sh

@@ -0,0 +1,14 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 test1.d -x -c213 > actual1.txt
+../../bin/dcd-client $1 test1.d -x -c239 >> actual1.txt
+../../bin/dcd-client $1 test1.d -x -c254 >> actual1.txt
+../../bin/dcd-client $1 test1.d -x -c265 >> actual1.txt
+diff actual1.txt expected1.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 test2.d -x -c132 > actual2.txt
+diff actual2.txt expected2.txt --strip-trailing-cr
+
+../../bin/dcd-client $1 test3.d -x -c83 > actual3.txt
+diff actual3.txt expected3.txt --strip-trailing-cr

tests/tc_typeof/test1.d

@@ -0,0 +1,32 @@
+struct Result
+{
+	int expected;
+}
+
+struct S
+{
+	Result member;
+
+	typeof(member) getMember()
+	{
+		return member;
+	}
+}
+
+typeof(S.member) staticMember()
+{
+	return S.init.member;
+}
+
+void test()
+{
+	S s;
+	auto a = S.getMember();
+	auto b = staticMember();
+	{
+		a.
+	}
+	{
+		b.
+	}
+}

tests/tc_typeof/test2.d

@@ -0,0 +1,15 @@
+struct MyTemplate(T)
+{
+	enum Enum { a, b }
+
+	T member1;
+}
+
+MyTemplate!long global2;
+
+void main()
+{
+	typeof(global2).Enum test;
+	test
+}
+

tests/tc_typeof/test3.d

@@ -0,0 +1,10 @@
+struct S { bool ok; }
+
+S global3;
+
+void main()
+{
+	typeof(global3)[] test;
+	test[0].
+}
+

tests/tc_ufcs_alias_this_completion/alias_this_on_function.d

@@ -0,0 +1,10 @@
+struct S { S* s; S get() { return *s; } alias get this; }
+
+void ufcsMatching(S value) {}
+void ufcsNonMatching(int value) {}
+
+void main()
+{
+	S s;
+	s.ufcs
+}

tests/tc_ufcs_alias_this_completion/expected_alias_this_on_function_test.txt

@@ -0,0 +1,2 @@
+identifiers
+ufcsMatching	F

tests/tc_ufcs_alias_this_completion/expected_plenty_alias_this_defined_test.txt

@@ -0,0 +1,2 @@
+identifiers
+ufcsA	F

tests/tc_ufcs_alias_this_completion/expected_plenty_alias_this_defined_test2.txt

@@ -0,0 +1,6 @@
+identifiers
+ufcsA	F
+ufcsB	F
+ufcsC	F
+ufcsD	F
+ufcsE	F

tests/tc_ufcs_alias_this_completion/plenty_alias_this_defined.d

@@ -0,0 +1,24 @@
+struct A { int x; }
+struct B { A a; alias a this; }
+struct C { B b; alias b this; }
+struct D { C c; alias c this; }
+struct E { D d; alias d this; }
+struct F { E e; alias e this; }
+
+void ufcsA(A a) {}
+void ufcsB(B b) {}
+void ufcsC(C c) {}
+void ufcsD(D d) {}
+void ufcsE(E e) {}
+
+void testA()
+{
+	A a;
+	a.ufcs // should only give ufcsA
+}
+
+void testE()
+{
+	E e;
+	e.ufcs // should give all the ufcs methods
+}

tests/tc_ufcs_alias_this_completion/run.sh

@@ -0,0 +1,25 @@
+set -e
+set -u
+
+#TEST CASE 0
+SOURCE_FILE_0=alias_this_on_function.d
+ACTUAL_FILE_NAME_0="actual_alias_this_on_function_test.txt"
+EXPECTED_FILE_NAME_0="expected_alias_this_on_function_test.txt"
+
+../../bin/dcd-client $1 -c152 $SOURCE_FILE_0 > $ACTUAL_FILE_NAME_0
+diff $ACTUAL_FILE_NAME_0 $EXPECTED_FILE_NAME_0 --strip-trailing-cr
+
+#TEST CASE 1
+SOURCE_FILE_1=plenty_alias_this_defined.d
+ACTUAL_FILE_NAME_1="actual_plenty_alias_this_defined_test.txt"
+EXPECTED_FILE_NAME_1="expected_plenty_alias_this_defined_test.txt"
+
+../../bin/dcd-client $1 -c305 $SOURCE_FILE_1 > $ACTUAL_FILE_NAME_1
+diff $ACTUAL_FILE_NAME_1 $EXPECTED_FILE_NAME_1 --strip-trailing-cr
+
+#TEST CASE 2
+ACTUAL_FILE_NAME_2="actual_plenty_alias_this_defined_test2.txt"
+EXPECTED_FILE_NAME_2="expected_plenty_alias_this_defined_test2.txt"
+
+../../bin/dcd-client $1 -c363 $SOURCE_FILE_1 > $ACTUAL_FILE_NAME_2
+diff $ACTUAL_FILE_NAME_2 $EXPECTED_FILE_NAME_2 --strip-trailing-cr

tests/tc_ufcs_array_type_completion/expected_array_test.txt

@@ -0,0 +1,3 @@
+identifiers
+arrayStuff1	F
+arrayStuff7	F

tests/tc_ufcs_array_type_completion/file.d

@@ -0,0 +1,13 @@
+void arrayStuff1(int[] x) { }
+void arrayStuff2(long[] x) { }
+void arrayStuff3(uint[] x) { }
+void arrayStuff4(T)(T[] x) { }
+void arrayStuff5(int[][] x) { }
+void arrayStuff6(int*[] x) { }
+void arrayStuff7(const(int)[] x) { }
+void doArray(int[] x, int[] y)
+{
+	y.arraySt
+	// TODO: arrayStuff4 isn't included yet, since we don't really process
+	// templates, but should be!
+}

tests/tc_ufcs_array_type_completion/run.sh

@@ -0,0 +1,5 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 -c266 file.d > actual_array_test.txt
+diff actual_array_test.txt expected_array_test.txt

tests/tc_ufcs_fundamental_types_completion/expected_bool_test.txt

@@ -6,5 +6,18 @@ max	k
 min	k
 sizeof	k
 someBool	F
+someByte	F
+someChar	F
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someShort	F
+someUbyte	F
+someUint	F
+someUlong	F
+someUshort	F
+someWchar	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_byte_test.txt

@@ -6,5 +6,17 @@ max	k
 min	k
 sizeof	k
 someByte	F
+someChar	F
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someShort	F
+someUbyte	F
+someUint	F
+someUlong	F
+someUshort	F
+someWchar	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_char_test.txt

@@ -5,6 +5,18 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someByte	F
 someChar	F
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someShort	F
+someUbyte	F
+someUint	F
+someUlong	F
+someUshort	F
+someWchar	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_dchar_test.txt

@@ -6,5 +6,11 @@ max	k
 min	k
 sizeof	k
 someDchar	F
+someDouble	F
+someFloat	F
+someInt	F
+someLong	F
+someReal	F
 someUint	F
+someUlong	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_double_test.txt

@@ -15,4 +15,6 @@ min_normal	k
 nan	k
 sizeof	k
 someDouble	F
+someFloat	F
+someReal	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_float_test.txt

@@ -14,5 +14,7 @@ min_exp	k
 min_normal	k
 nan	k
 sizeof	k
+someDouble	F
 someFloat	F
+someReal	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_int_test.txt

@@ -5,5 +5,12 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someUint	F
+someUlong	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_long_test.txt

@@ -5,5 +5,9 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDouble	F
+someFloat	F
 someLong	F
+someReal	F
+someUlong	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_real_test.txt

@@ -14,5 +14,7 @@ min_exp	k
 min_normal	k
 nan	k
 sizeof	k
+someDouble	F
+someFloat	F
 someReal	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_short_test.txt

@@ -5,6 +5,15 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
 someShort	F
+someUint	F
+someUlong	F
+someUshort	F
+someWchar	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_ubyte_test.txt

@@ -5,6 +5,18 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someByte	F
+someChar	F
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someShort	F
 someUbyte	F
+someUint	F
+someUlong	F
+someUshort	F
+someWchar	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_uint_test.txt

@@ -5,5 +5,12 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDchar	F
+someDouble	F
+someFloat	F
+someInt	F
+someLong	F
+someReal	F
 someUint	F
+someUlong	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_ulong_test.txt

@@ -5,5 +5,9 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDouble	F
+someFloat	F
+someLong	F
+someReal	F
 someUlong	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_ushort_test.txt

@@ -5,6 +5,15 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someShort	F
+someUint	F
+someUlong	F
 someUshort	F
+someWchar	F
 stringof	k

tests/tc_ufcs_fundamental_types_completion/expected_wchar_test.txt

@@ -5,6 +5,15 @@ mangleof	k
 max	k
 min	k
 sizeof	k
+someDchar	F
+someDouble	F
+someFloat	F
 someInt	F
+someLong	F
+someReal	F
+someShort	F
+someUint	F
+someUlong	F
+someUshort	F
 someWchar	F
 stringof	k