upgrade libdparse

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

.github/workflows/ci.yml

@@ -11,7 +11,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        # use older ubuntu / linux version for glibc compatibility
+        os: [ubuntu-20.04, windows-latest, macos-latest]
         dc:
           - ldc-latest
           - dmd-latest
@@ -27,8 +28,8 @@ jobs:
             build: debug
             libdparse-version: min
           # old compiler tests
-          - { os: ubuntu-latest, dc: dmd-2.095.1, libdparse-version: min, build: debug, arch: x86_64 }
-          - { os: ubuntu-latest, dc: ldc-1.25.0, libdparse-version: min, build: debug, arch: x86_64 }
+          - { os: ubuntu-20.04, dc: dmd-2.095.1, libdparse-version: min, build: debug, arch: x86_64 }
+          - { os: ubuntu-20.04, dc: ldc-1.25.0, libdparse-version: min, build: debug, arch: x86_64 }
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3
@@ -44,8 +45,8 @@ jobs:
 
       - name: Build
         run: |
-          rdmd ./d-test-utils/test_with_package.d $LIBDPARSE_VERSION libdparse -- dub build --build=${{ matrix.build }} --config=client --arch=${{ matrix.arch }}
-          rdmd ./d-test-utils/test_with_package.d $LIBDPARSE_VERSION libdparse -- dub build --build=${{ matrix.build }} --config=server --arch=${{ matrix.arch }}
+          dub build --build=${{ matrix.build }} --config=client --arch=${{ matrix.arch }}
+          dub build --build=${{ matrix.build }} --config=server --arch=${{ matrix.arch }}
 
       # Tests
 
@@ -65,17 +66,23 @@ jobs:
           cd dsymbol
           rdmd ../d-test-utils/test_with_package.d $LIBDPARSE_VERSION libdparse -- dub test
 
+      # test that both lowest supplied and highest available libdparse versions are compatible (for DUB users depending on DCD)
+      - name: Test dependency versions
+        run: |
+          rdmd ./d-test-utils/test_with_package.d $LIBDPARSE_VERSION libdparse -- dub build --build=${{ matrix.build }} --config=client --arch=${{ matrix.arch }}
+          rdmd ./d-test-utils/test_with_package.d $LIBDPARSE_VERSION libdparse -- dub build --build=${{ matrix.build }} --config=server --arch=${{ matrix.arch }}
+
       - 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/

.github/workflows/release.yml

@@ -8,7 +8,8 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        # use older ubuntu / linux version for glibc compatibility
+        os: [ubuntu-20.04, windows-latest, macos-latest]
         dc:
           - ldc-latest
         arch:

.gitignore

@@ -16,6 +16,10 @@ perf.data.old
 
 # Valgrind reports
 callgrind.*
+massif.*
+
+# D profiling tools
+profilegc.log
 
 # GDB temp files
 .gdb_history
@@ -24,7 +28,12 @@ callgrind.*
 tests/tc*/actual*.txt
 stderr.txt
 stdout.txt
+# script-generated expected with absolute file paths
+tests/tc_locate_ufcs_function/expected.txt
+tests/tc_recursive_public_import/expected.txt
 
 # Dub files
 .dub
 dub.selections.json
+!/dub.selections.json
+dcd*-test-*

README.md

@@ -35,9 +35,9 @@ the issue.)
 	* *alias this*
 	* *auto* declarations (Mostly)
 	* *with* statements
-	* Simple UFCS suggestions for concrete types.
+	* Simple UFCS suggestions for concrete types and fundamental types.
 * Not working:
-	* UFCS completion for templates, literals, UFCS function arguments, and '.' chaining with other UFCS functions.
+	* UFCS completion for templates, literals, aliased types, UFCS function arguments, and '.' chaining with other UFCS functions.
 	* UFCS calltips
 	* Autocompletion of declarations with template arguments (This will work to some extent, but it won't do things like replace T with int)
 	* Determining the type of an enum member when no base type is specified, but the first member has an initializer
@@ -175,13 +175,19 @@ a tab separated format:
 * definition: function or variable definition string or close approximation for information display purpose
 * symbol location: in which file (or `stdin`) & byte offset this symbol is defined. Separated with a space.
 * documentation: escaped documentation string of this symbol
+* typeOf: resolved type name of this symbol:
+	<!-- the items in list are copied from messages.d -->
+	* For variables, fields, globals, constants: resolved type or empty if unresolved.
+	* For functions: resolved return type or empty if unresolved.
+	* For constructors: may be struct/class name or empty in any case.
+	* Otherwise (probably) empty.
 
 #### Example `--extended` output
 
 	identifiers
 	libraryFunction	f	Tuple!long libraryFunction(string s, string s2)	stdin 190	foobar
-	libraryFunction	f	int* libraryFunction(string s)	stdin 99	Hello\nWorld
-	libraryVariable	v	int libraryVariable	stdin 56	My variable
+	libraryFunction	f	int* libraryFunction(string s)	stdin 99	Hello\nWorld	int*
+	libraryVariable	v	int libraryVariable	stdin 56	My variable	int
 	libreTypes	g		stdin 298
 
 #### Note
@@ -190,6 +196,9 @@ DCD's output will start with "identifiers" when completing at a left paren
 character if the keywords *pragma*, *scope*, *__traits*, *extern*, or *version*
 were just before the paren.
 
+Types in the calltips and typeOf column may not be complete, e.g. missing
+template parameters or typeof expressions, etc.
+
 ### Parenthesis completion
 
 When the first line of output is "calltips", the editor should display a function
@@ -305,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/dub.sdl

@@ -5,5 +5,5 @@ preBuildCommands "\"$DC\" -run \"$PACKAGE_DIR/dubhash.d\""
 sourcePaths "src"
 importPaths "src"
 
-dependency "msgpack-d" version="1.0.1"
+dependency "msgpack-d" version="~>1.0"
 versions "built_with_dub"

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
 }
 
@@ -152,6 +154,14 @@ struct AutocompleteResponse
 		 * Documentation associated with this symbol.
 		 */
 		string documentation;
+		// when changing the behavior here, update README.md
+		/**
+		 * For variables, fields, globals, constants: resolved type or empty if unresolved.
+		 * For functions: resolved return type or empty if unresolved.
+		 * For constructors: may be struct/class name or empty in any case.
+		 * Otherwise (probably) empty.
+		 */
+		string typeOf;
 	}
 
 	/**
@@ -252,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 <0.22.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

@@ -40,6 +40,15 @@ TTree!(DSymbol*, SymbolsAllocator, true, "a < b") classSymbols;
  */
 TTree!(DSymbol*, SymbolsAllocator, true, "a < b") enumSymbols;
 
+/**
+ * Pointer properties (when not implicitly dereferencing)
+ */
+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
  */
@@ -191,6 +200,12 @@ static this()
 	aggregateSymbols.insert(stringof_);
 	aggregateSymbols.insert(init);
 
+	pointerSymbols.insert(mangleof_);
+	pointerSymbols.insert(alignof_);
+	pointerSymbols.insert(sizeof_);
+	pointerSymbols.insert(stringof_);
+	pointerSymbols.insert(init);
+
 	classSymbols.insert(makeSymbol("classinfo", CompletionKind.variableName));
 	classSymbols.insert(tupleof);
 	classSymbols.insert(makeSymbol("__vptr", CompletionKind.variableName));
@@ -283,6 +298,7 @@ static ~this()
 	destroy(aggregateSymbols);
 	destroy(classSymbols);
 	destroy(enumSymbols);
+	destroy(pointerSymbols);
 
 	foreach (sym; symbolsMadeHere[])
 		destroy(*sym);

dsymbol/src/dsymbol/conversion/first.d

@@ -33,9 +33,11 @@ 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;
 
 /**
@@ -129,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;
@@ -148,6 +151,10 @@ final class FirstPass : ASTVisitor
 			processParameters(currentSymbol, dec.returnType,
 					currentSymbol.acSymbol.name, dec.parameters, dec.templateParameters);
 		}
+
+		if (dec.returnType !is null){
+			addTypeToLookups(currentSymbol.typeLookups, dec.returnType);
+		}
 	}
 
 	override void visit(const FunctionLiteralExpression exp)
@@ -264,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);
@@ -712,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);
 	}
@@ -749,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);
 
 		}
@@ -757,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;
 
@@ -778,7 +786,6 @@ private:
 
 	void createConstructor()
 	{
-		import std.array : appender;
 		import std.range : zip;
 
 		auto app = appender!string();
@@ -902,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);
 
@@ -915,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)
@@ -960,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;
 
@@ -1037,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);
 
@@ -1064,7 +1110,6 @@ private:
 	istring formatCallTip(const Type returnType, string name,
 		const Parameters parameters, const TemplateParameters templateParameters)
 	{
-		import std.array : appender;
 
 		auto app = appender!string();
 		if (returnType !is null)
@@ -1082,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,
@@ -1107,28 +1163,24 @@ 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)
 		{
-			if (suffix.star != tok!"")
-				continue;
-			else if (suffix.type)
+			if (suffix.type)
 				lookup.breadcrumbs.insert(ASSOC_ARRAY_SYMBOL_NAME);
 			else if (suffix.array)
 				lookup.breadcrumbs.insert(ARRAY_SYMBOL_NAME);
@@ -1136,7 +1188,6 @@ private:
 				lookup.breadcrumbs.insert(POINTER_SYMBOL_NAME);
 			else if (suffix.delegateOrFunction != tok!"")
 			{
-				import std.array : appender;
 				auto app = appender!string();
 				formatNode(app, type);
 				istring callTip = istring(app.data);
@@ -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
@@ -1341,7 +1396,6 @@ void writeIotcTo(T)(const IdentifierOrTemplateChain iotc, ref T output) nothrow
 static istring convertChainToImportPath(const IdentifierChain ic)
 {
 	import std.path : dirSeparator;
-	import std.array : appender;
 	auto app = appender!string();
 	foreach (i, ident; ic.identifiers)
 	{
@@ -1362,6 +1416,7 @@ class InitializerVisitor : ASTVisitor
 	}
 
 	alias visit = ASTVisitor.visit;
+	alias dynamicDispatch = ASTVisitor.dynamicDispatch;
 
 	override void visit(const FunctionLiteralExpression exp)
 	{
@@ -1443,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);
@@ -1520,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)
 	{
@@ -1535,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;
@@ -1548,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

@@ -25,13 +25,16 @@ import dparse.rollback_allocator;
 import dsymbol.cache_entry;
 import dsymbol.conversion.first;
 import dsymbol.conversion.second;
+import dsymbol.conversion.third;
 import dsymbol.modulecache;
 import dsymbol.scope_;
 import dsymbol.semantic;
 import dsymbol.string_interning;
 import dsymbol.symbol;
+import dsymbol.ufcs;
 import std.algorithm;
 import std.experimental.allocator;
+import containers.hashset;
 
 /**
  * Used by autocompletion.
@@ -47,9 +50,14 @@ ScopeSymbolPair generateAutocompleteTrees(const(Token)[] tokens,
 	first.run();
 
 	secondPass(first.rootSymbol, first.moduleScope, cache);
+
+	thirdPass(first.rootSymbol, first.moduleScope, cache, cursorPosition);
+
+    auto ufcsSymbols = getUFCSSymbolsForCursor(first.moduleScope, tokens, cursorPosition);
+
 	auto r = move(first.rootSymbol.acSymbol);
 	typeid(SemanticSymbol).destroy(first.rootSymbol);
-	return ScopeSymbolPair(r, move(first.moduleScope));
+	return ScopeSymbolPair(r, move(first.moduleScope), ufcsSymbols);
 }
 
 struct ScopeSymbolPair
@@ -58,10 +66,13 @@ struct ScopeSymbolPair
 	{
 		typeid(DSymbol).destroy(symbol);
 		typeid(Scope).destroy(scope_);
+		// don't destroy ufcsSymbols contents since we don't own the values
+		// array itself is GC-allocated, so we just let it live
 	}
 
 	DSymbol* symbol;
 	Scope* scope_;
+	DSymbol*[] ufcsSymbols;
 }
 
 /**
@@ -104,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

@@ -33,6 +33,8 @@ import std.experimental.allocator.gc_allocator : GCAllocator;
 import std.experimental.logger;
 import dparse.ast;
 import dparse.lexer;
+import std.algorithm : filter;
+import std.range;
 
 void secondPass(SemanticSymbol* currentSymbol, Scope* moduleScope, ref ModuleCache cache)
 {
@@ -146,7 +148,8 @@ do
 	{
 		if (moduleSymbol is null)
 		{
-			DeferredSymbol* deferred = DeferredSymbolsAllocator.instance.make!DeferredSymbol(acSymbol);
+			DeferredSymbol* deferred = DeferredSymbolsAllocator.instance.make!DeferredSymbol(
+				acSymbol);
 			cache.deferredSymbols.insert(deferred);
 		}
 		else
@@ -177,29 +180,31 @@ do
 	while (!lookup.breadcrumbs.empty)
 	{
 		auto back = lookup.breadcrumbs.back;
-		immutable bool isArr = back == ARRAY_SYMBOL_NAME;
-		immutable bool isAssoc = back == ASSOC_ARRAY_SYMBOL_NAME;
-		immutable bool isFunction = back == FUNCTION_SYMBOL_NAME;
-		if (back == POINTER_SYMBOL_NAME)
-		{
-			lastSuffix.isPointer = true;
-			lookup.breadcrumbs.popBack();
-			continue;
-		}
-		if (!isArr && !isAssoc && !isFunction)
-			break;
-		immutable qualifier = isAssoc ? SymbolQualifier.assocArray :
-			(isFunction ? SymbolQualifier.func : SymbolQualifier.array);
+		SymbolQualifier qualifier;
+		if (back == ARRAY_SYMBOL_NAME) qualifier = SymbolQualifier.array;
+		else if (back == ASSOC_ARRAY_SYMBOL_NAME) qualifier = SymbolQualifier.assocArray;
+		else if (back == FUNCTION_SYMBOL_NAME) qualifier = SymbolQualifier.func;
+		else if (back == POINTER_SYMBOL_NAME) qualifier = SymbolQualifier.pointer;
+		else break;
+
 		lastSuffix = GCAllocator.instance.make!DSymbol(back, CompletionKind.dummy, lastSuffix);
 		lastSuffix.qualifier = qualifier;
 		lastSuffix.ownType = true;
-		if (isFunction)
+
+		final switch (qualifier)
 		{
+		case SymbolQualifier.none:
+		case SymbolQualifier.selectiveImport:
+			assert(false, "this should never be generated");
+		case SymbolQualifier.func:
 			lookup.breadcrumbs.popBack();
 			lastSuffix.callTip = lookup.breadcrumbs.back();
+			break;
+		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;
 		}
-		else
-			lastSuffix.addChildren(isArr ? arraySymbols[] : assocArraySymbols[], false);
 
 		if (suffix is null)
 			suffix = lastSuffix;
@@ -232,20 +237,48 @@ 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
+				{
+					// store the part, that'll be useful to resolve the type later
+					symbol.typeSymbolName = istring(part);
 					return;
+				}
 			}
 		}
 		else
@@ -264,7 +297,6 @@ do
 				return;
 			currentSymbol = currentSymbol.getFirstPartNamed(part);
 		}
-		++i;
 		if (currentSymbol is null)
 			return;
 	}
@@ -278,7 +310,7 @@ do
 		symbol.ownType = true;
 		if (currentSymbol is null && !remainingImports.empty)
 		{
-//			info("Deferring type resolution for ", symbol.name);
+			//			info("Deferring type resolution for ", symbol.name);
 			auto deferred = DeferredSymbolsAllocator.instance.make!DeferredSymbol(suffix);
 			// TODO: The scope has ownership of the import information
 			deferred.imports.insert(remainingImports[]);
@@ -294,7 +326,7 @@ do
 	else if (!remainingImports.empty)
 	{
 		auto deferred = DeferredSymbolsAllocator.instance.make!DeferredSymbol(symbol);
-//		info("Deferring type resolution for ", symbol.name);
+		//		info("Deferring type resolution for ", symbol.name);
 		// TODO: The scope has ownership of the import information
 		deferred.imports.insert(remainingImports[]);
 		deferred.typeLookups.insert(lookup);
@@ -302,13 +334,115 @@ 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,
 	Scope* moduleScope, ref ModuleCache cache)
 {
-	import std.algorithm : filter;
-
 	outer: foreach (TypeLookup* lookup; typeLookups[])
 	{
 		if (lookup.kind != TypeLookupKind.inherit)
@@ -350,14 +484,15 @@ void resolveInheritance(DSymbol* symbol, ref TypeLookups typeLookups,
 void resolveAliasThis(DSymbol* symbol,
 	ref TypeLookups typeLookups, Scope* moduleScope, ref ModuleCache cache)
 {
-	import std.algorithm : filter;
-
 	foreach (aliasThis; typeLookups[].filter!(a => a.kind == TypeLookupKind.aliasThis))
 	{
 		assert(aliasThis.breadcrumbs.length > 0);
 		auto parts = symbol.getPartsByName(aliasThis.breadcrumbs.front);
 		if (parts.length == 0 || parts[0].type is null)
 			continue;
+
+		symbol.aliasThisSymbols ~= parts;
+
 		DSymbol* s = GCAllocator.instance.make!DSymbol(IMPORT_SYMBOL_NAME,
 			CompletionKind.importSymbol, parts[0].type);
 		symbol.addChild(s, true);
@@ -370,8 +505,6 @@ void resolveAliasThis(DSymbol* symbol,
 void resolveMixinTemplates(DSymbol* symbol,
 	ref TypeLookups typeLookups, Scope* moduleScope, ref ModuleCache cache)
 {
-	import std.algorithm : filter;
-
 	foreach (mix; typeLookups[].filter!(a => a.kind == TypeLookupKind.mixinTemplate))
 	{
 		assert(mix.breadcrumbs.length > 0);
@@ -405,120 +538,22 @@ void resolveMixinTemplates(DSymbol* symbol,
 void resolveType(DSymbol* symbol, ref TypeLookups typeLookups,
 	Scope* moduleScope, ref ModuleCache cache)
 {
-
-	import std.conv;
-
-	if (typeLookups.length == 0)
-		return;
-	assert(typeLookups.length == 1);
-	auto lookup = typeLookups.front;
-	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);
-	else
-		assert(false, "How did this happen?");
-}
-
-
-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;
-		}
+	// going through the lookups
+	foreach(lookup; typeLookups) {
+		if (lookup.kind == TypeLookupKind.varOrFunType)
+			resolveTypeFromType(symbol, lookup, moduleScope, cache, null);
+		// issue 94
+		else if (lookup.kind == TypeLookupKind.inherit)
+			resolveInheritance(symbol, typeLookups, moduleScope, cache);
 		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;
+			assert(false, "How did this happen?");
 		}
-		else if (crumb == ARRAY_SYMBOL_NAME)
-		{
-			typeSwap(currentSymbol);
-			if (currentSymbol is null)
-				return;
-
-			// Index expressions can be an array index or an AA index
-			if (currentSymbol.qualifier == SymbolQualifier.array
-					|| currentSymbol.qualifier == SymbolQualifier.assocArray
-					|| 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
-			&& (currentSymbol.kind == CompletionKind.variableName
+		&& (currentSymbol.kind == CompletionKind.variableName
 			|| currentSymbol.kind == CompletionKind.importSymbol
 			|| currentSymbol.kind == CompletionKind.withSymbol
 			|| currentSymbol.kind == CompletionKind.aliasName))

dsymbol/src/dsymbol/conversion/third.d

@@ -0,0 +1,145 @@
+/**
+ * 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 dsymbol.conversion.third;
+
+import dsymbol.modulecache;
+import dsymbol.scope_;
+import dsymbol.semantic;
+import dsymbol.symbol;
+import dsymbol.string_interning;
+import dsymbol.deferred;
+
+import containers.hashset;
+
+
+/**
+ * Used to resolve the type of remaining symbols that were left out due to modules being parsed from other modules that depend on each other (public imports)
+ * It will start from the scope of interest at the cursorPosition, and it'll traverse the scope from bottom to top and check if the symbol's type is know
+ * If it is, then it'll set its type
+ * If the symbol is not found, then it'll do nothing 
+ */
+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);
+}
+
+/**
+ * Used to resolve missing symbols within a scope
+ */
+void tryResolve(Scope* sc, ref ModuleCache cache)
+{
+    if (sc is null) return;
+    auto symbols = sc.symbols;
+    foreach (item; symbols)
+    {
+        DSymbol* target = item.type;
+
+        if (target !is null)
+        {
+            HashSet!size_t visited;
+            foreach (part; target.opSlice())
+            {
+                resolvePart(part, sc, cache, visited);
+            }
+        }
+    }
+    if (sc.parent !is null) tryResolve(sc.parent, cache);
+}
+
+void resolvePart(DSymbol* part, Scope* sc, ref ModuleCache cache, ref HashSet!size_t visited)
+{
+    if (visited.contains(cast(size_t) part))
+        return;
+    visited.insert(cast(size_t) part);
+
+    // no type but a typeSymbolName, let's resolve its type
+    if (part.type is null && part.typeSymbolName !is null)
+    {
+        import std.string: indexOf;
+        auto typeName = part.typeSymbolName;
+
+        // check if it is available in the scope
+        // otherwise grab its module symbol to check if it's publickly available
+        auto result = sc.getSymbolsAtGlobalScope(istring(typeName));
+        if (result.length > 0)
+        {
+            part.type = result[0];
+            return;
+        }
+        else
+        {
+            if (part.symbolFile == "stdin") return;
+            auto moduleSymbol = cache.getModuleSymbol(part.symbolFile);
+            auto first = moduleSymbol.getFirstPartNamed(istring(typeName));
+            if (first !is null)
+            {
+                part.type = first;
+                return;
+            }
+            else
+            {
+                // type couldn't be found, that's stuff like templates
+                // now we could try to resolve them!
+                // warning("can't resolve: ", part.name, " callTip: ", typeName);
+                return;
+            }
+        }
+    }
+
+    if (part.type !is null)
+    {
+        foreach (typePart; part.type.opSlice())
+            resolvePart(typePart, sc, cache, visited);
+    }
+}

dsymbol/src/dsymbol/symbol.d

@@ -131,6 +131,10 @@ enum SymbolQualifier : ubyte
 	func,
 	/// Selective import
 	selectiveImport,
+	/// The symbol is a pointer
+	pointer,
+	/// The symbol is templated
+	templated,
 }
 
 /**
@@ -228,6 +232,11 @@ struct DSymbol
 			return;
 		visited.insert(cast(size_t) &this);
 
+		// pointers are implicitly dereferenced on members (a single layer)
+		if (qualifier == SymbolQualifier.pointer
+			&& (this.type && this.type.qualifier != SymbolQualifier.pointer))
+			return type.getParts!OR(name, app, visited, onlyOne);
+
 		if (name is null)
 		{
 			foreach (part; parts[].filter!(a => a.name != IMPORT_SYMBOL_NAME))
@@ -375,17 +384,19 @@ struct DSymbol
 	// TODO: assert that the type is not a function
 	DSymbol* type;
 
-	/**
-	 * Names of function arguments
-	 */
-	// TODO: remove since we have function arguments
-	UnrolledList!(istring) argNames;
+	// Is alias this symbols
+	DSymbol*[] aliasThisSymbols;
 
 	/**
 	 * Function parameter symbols
 	 */
 	DSymbol*[] functionParameters;
 
+	/**
+	 * Used to resolve the type
+	 */
+	istring typeSymbolName;
+
 	private uint _location;
 
 	/**
@@ -418,15 +429,86 @@ 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,
-		bool, "isPointer", 1,
-		ubyte, "", 5));
+		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;
+	}
+
 	/// Protection level for this symbol
 	IdType protection;
 
+	string formatType(string suffix = "") const
+	{
+		if (kind == CompletionKind.functionName)
+		{
+			if (type) // try to give return type symbol
+				return type.formatType;
+			else // null if unresolved, user can manually pick .name or .callTip if needed
+				return null;
+		}
+		else if (name == POINTER_SYMBOL_NAME)
+		{
+			if (!type)
+				return suffix ~ "*";
+			else
+				return type.formatType(suffix ~ "*");
+		}
+		else if (name == ARRAY_SYMBOL_NAME)
+		{
+			if (!type)
+				return suffix ~ "[]";
+			else
+				return type.formatType(suffix ~ "[]");
+		}
+		else if (name == ASSOC_ARRAY_SYMBOL_NAME)
+		{
+			// TODO: include AA key type
+			if (!type)
+				return suffix ~ "[...]";
+			else
+				return type.formatType(suffix ~ "[...]");
+		}
+		else
+		{
+			// TODO: include template parameters
+			return name ~ suffix;
+		}
+	}
 }
 
 /**

dsymbol/src/dsymbol/tests.d

@@ -3,10 +3,11 @@ module dsymbol.tests;
 import std.experimental.allocator;
 import dparse.ast, dparse.parser, dparse.lexer, dparse.rollback_allocator;
 import dsymbol.cache_entry, dsymbol.modulecache, dsymbol.symbol;
-import dsymbol.conversion, dsymbol.conversion.first, dsymbol.conversion.second;
+import dsymbol.conversion, dsymbol.conversion.first, dsymbol.conversion.second, dsymbol.conversion.third;
 import dsymbol.semantic, dsymbol.string_interning, dsymbol.builtin.names;
 import std.file, std.path, std.format;
 import std.stdio : writeln, stdout;
+import dsymbol.ufcs;
 
 /**
  * Parses `source`, caches its symbols and compares the the cache content
@@ -126,6 +127,101 @@ unittest
 	}
 }
 
+unittest
+{
+	ModuleCache cache;
+	writeln("Get return type name");
+	auto source = q{ int meaningOfLife() { return 42; } };
+	auto pair = generateAutocompleteTrees(source, cache);
+	auto meaningOfLife = pair.symbol.getFirstPartNamed(istring("meaningOfLife"));
+	assert(meaningOfLife.type.name == "int");
+}
+
+unittest
+{
+	ModuleCache cache;
+	writeln("Get return type name from class method");
+	auto source = q{ class Life { uint meaningOfLife() { return 42; } }};
+	auto pair = generateAutocompleteTrees(source, cache);
+	auto lifeClass = pair.symbol.getFirstPartNamed(istring("Life"));
+	auto meaningOfLife = lifeClass.getFirstPartNamed(istring("meaningOfLife"));
+	assert(meaningOfLife.type.name == "uint");
+}
+
+unittest
+{
+	ModuleCache cache;
+	writeln("Return type of auto should be null");
+	auto source = q{ class Life { auto meaningOfLife() { return 42; } }};
+	auto pair = generateAutocompleteTrees(source, cache);
+	auto lifeClass = pair.symbol.getFirstPartNamed(istring("Life"));
+	auto meaningOfLife = lifeClass.getFirstPartNamed(istring("meaningOfLife"));
+	assert(meaningOfLife.type is null);
+}
+
+unittest
+{
+	ModuleCache cache;
+	writeln("Return type of scope should be null");
+	auto source = q{ class Life { scope meaningOfLife() { return 42; } }};
+	auto pair = generateAutocompleteTrees(source, cache);
+	auto lifeClass = pair.symbol.getFirstPartNamed(istring("Life"));
+	auto meaningOfLife = lifeClass.getFirstPartNamed(istring("meaningOfLife"));
+	assert(meaningOfLife.type is null);
+}
+
+unittest
+{
+	ModuleCache cache;
+	writeln("Templated return type should be deduced correctly");
+	auto source = q{ 
+		struct AnswerToLife(T) {
+			T life;
+		}
+		AnswerToLife!int meaningOfLife() { return AnswerToLife!int(42);  }
+
+	};
+	ScopeSymbolPair pair = generateAutocompleteTrees(source, cache);
+	auto answerToLife = pair.symbol.getFirstPartNamed(istring("AnswerToLife"));
+	DSymbol* meaningOfLife = pair.symbol.getFirstPartNamed(istring("meaningOfLife"));
+	assert(meaningOfLife.type.name == "AnswerToLife");
+	assert(meaningOfLife.type is answerToLife);
+
+}
+
+unittest
+{
+	ModuleCache cache;
+	writeln("Array return type should be deduced correctly");
+	auto source = q{ 
+		int[] meaningOfLife() { return [42];  }
+
+	};
+	ScopeSymbolPair pair = generateAutocompleteTrees(source, cache);
+	DSymbol* meaningOfLife = pair.symbol.getFirstPartNamed(istring("meaningOfLife"));
+	assert(meaningOfLife.type.name == "*arr*");
+
+}
+
+unittest
+{
+	ModuleCache cache;
+	writeln("Int* return type should be deduced correctly");
+	auto source = q{ 
+		int* meaningOfLife()
+		{ 
+			auto life = 42;
+			return &life;
+		}
+
+	};
+	ScopeSymbolPair pair = generateAutocompleteTrees(source, cache);
+	DSymbol* meaningOfLife = pair.symbol.getFirstPartNamed(istring("meaningOfLife"));
+	writeln(meaningOfLife.type.formatType);
+	assert(meaningOfLife.type.formatType == "int*");
+}
+
+
 unittest
 {
 	ModuleCache cache;
@@ -239,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);
 	}
 	{
@@ -247,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);
 	}
 	{
@@ -255,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);
 	}
 	{
@@ -263,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);
 	}
@@ -272,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);
 	}
 }
@@ -318,7 +423,7 @@ unittest
 	writeln("Running template type parameters tests...");
 	{
 		auto source = q{ struct Foo(T : int){} struct Bar(T : Foo){} };
-		auto pair = generateAutocompleteTrees(source, "", 0, cache);
+		auto pair = generateAutocompleteTreesProd(source, "", 0, cache);
 		DSymbol* T1 = pair.symbol.getFirstPartNamed(internString("Foo"));
 		DSymbol* T2 = T1.getFirstPartNamed(internString("T"));
 		assert(T2.type.name == "int");
@@ -329,7 +434,7 @@ unittest
 	}
 	{
 		auto source = q{ struct Foo(T){ }};
-		auto pair = generateAutocompleteTrees(source, "", 0, cache);
+		auto pair = generateAutocompleteTreesProd(source, "", 0, cache);
 		DSymbol* T1 = pair.symbol.getFirstPartNamed(internString("Foo"));
 		assert(T1);
 		DSymbol* T2 = T1.getFirstPartNamed(internString("T"));
@@ -344,7 +449,7 @@ unittest
 
 	writeln("Running template variadic parameters tests...");
 	auto source = q{ struct Foo(T...){ }};
-	auto pair = generateAutocompleteTrees(source, "", 0, cache);
+	auto pair = generateAutocompleteTreesProd(source, "", 0, cache);
 	DSymbol* T1 = pair.symbol.getFirstPartNamed(internString("Foo"));
 	assert(T1);
 	DSymbol* T2 = T1.getFirstPartNamed(internString("T"));
@@ -433,15 +538,14 @@ unittest
 
 	writeln("Testing protection scopes");
 	auto source = q{version(all) { private: } struct Foo{ }};
-	auto pair = generateAutocompleteTrees(source, "", 0, cache);
+	auto pair = generateAutocompleteTreesProd(source, "", 0, cache);
 	DSymbol* T1 = pair.symbol.getFirstPartNamed(internString("Foo"));
 	assert(T1);
 	assert(T1.protection != tok!"private");
 }
 
 // check for memory leaks on thread termination (in static constructors)
-version (linux)
-unittest
+version (linux) unittest
 {
 	import core.memory : GC;
 	import core.thread : Thread;
@@ -489,6 +593,7 @@ static this()
 {
 	stringCache = StringCache(StringCache.defaultBucketCount);
 }
+
 static ~this()
 {
 	destroy(stringCache);
@@ -503,6 +608,7 @@ const(Token)[] lex(string source, string filename)
 {
 	import dparse.lexer : getTokensForParser;
 	import std.string : representation;
+
 	LexerConfig config;
 	config.fileName = filename;
 	return getTokensForParser(source.dup.representation, config, &stringCache);
@@ -531,7 +637,7 @@ ScopeSymbolPair generateAutocompleteTrees(string source, ref ModuleCache cache)
 	return generateAutocompleteTrees(source, randomDFilename, cache);
 }
 
-ScopeSymbolPair generateAutocompleteTrees(string source, string filename, ref ModuleCache cache)
+ScopeSymbolPair generateAutocompleteTrees(string source, string filename, ref ModuleCache cache, size_t cursorPosition = -1)
 {
 	auto tokens = lex(source);
 	RollbackAllocator rba;
@@ -540,21 +646,109 @@ ScopeSymbolPair generateAutocompleteTrees(string source, string filename, ref Mo
 	scope first = new FirstPass(m, internString(filename), &cache);
 	first.run();
 
+
 	secondPass(first.rootSymbol, first.moduleScope, cache);
+	thirdPass(first.rootSymbol, first.moduleScope, cache, cursorPosition);
+	auto ufcsSymbols = getUFCSSymbolsForCursor(first.moduleScope, tokens, cursorPosition);
 	auto r = first.rootSymbol.acSymbol;
 	typeid(SemanticSymbol).destroy(first.rootSymbol);
-	return ScopeSymbolPair(r, first.moduleScope);
+	return ScopeSymbolPair(r, first.moduleScope, ufcsSymbols);
 }
 
-ScopeSymbolPair generateAutocompleteTrees(string source, size_t cursorPosition, ref ModuleCache cache)
-{
-	return generateAutocompleteTrees(source, null, cache);
-}
-
-ScopeSymbolPair generateAutocompleteTrees(string source, string filename, size_t cursorPosition, ref ModuleCache cache)
+ScopeSymbolPair generateAutocompleteTreesProd(string source, string filename, size_t cursorPosition, ref ModuleCache cache)
 {
 	auto tokens = lex(source);
 	RollbackAllocator rba;
 	return dsymbol.conversion.generateAutocompleteTrees(
 		tokens, &rba, cursorPosition, cache);
 }
+
+
+
+version (linux)
+{
+
+	unittest
+	{
+		enum string ufcsExampleCode =
+q{class Incrementer
+{
+	int run(int x)
+	{
+		return x++;
+	}
+}
+int increment(int x)
+{
+	return x++;
+}
+void doIncrement()
+{
+	int life = 42;
+	life.
+}};
+
+
+		writeln("Getting UFCS Symbols For life");
+		ModuleCache cache;
+		// position of variable life 
+		size_t cursorPos = 139;
+		auto pair = generateAutocompleteTreesProd(ufcsExampleCode, randomDFilename, cursorPos, cache);
+		assert(pair.ufcsSymbols.length > 0);
+		assert(pair.ufcsSymbols[0].name == "increment");
+
+	}
+
+enum string ufcsTemplateExampleCode =
+q{int increment(T)(T x)
+{
+	return x++;
+}
+void doIncrement()
+{
+	int life = 42;
+	life.
+}};
+
+	unittest
+	{
+		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;
+		// position of variable life 
+		size_t cursorPos = 82;
+		auto pair = generateAutocompleteTreesProd(ufcsTemplateExampleCode, randomDFilename, cursorPos, cache);
+		assert(pair.ufcsSymbols.length > 0);
+		assert(pair.ufcsSymbols[0].name == "increment");
+
+	}
+
+	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

@@ -0,0 +1,458 @@
+module dsymbol.ufcs;
+
+import dsymbol.symbol;
+import dsymbol.scope_;
+import dsymbol.builtin.names;
+import dsymbol.utils;
+import dparse.lexer : tok, Token;
+import std.functional : unaryFun;
+import std.algorithm;
+import std.array;
+import std.range;
+import std.string;
+import std.regex;
+import containers.hashset : HashSet;
+import std.experimental.logger;
+
+enum CompletionContext
+{
+    UnknownCompletion,
+    DotCompletion,
+    ParenCompletion,
+}
+
+
+struct TokenCursorResult
+{
+    CompletionContext completionContext;
+    istring functionName;
+    Token significantToken;
+    string partialIdentifier;
+}
+
+// https://dlang.org/spec/type.html#implicit-conversions
+enum string[string] INTEGER_PROMOTIONS = [
+        "bool": "byte",
+        "byte": "int",
+        "ubyte": "int",
+        "short": "int",
+        "ushort": "int",
+        "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_NUMBER_OF_MATCHING_RUNS = 50;
+
+private const(DSymbol)* deduceSymbolTypeByToken(Scope* completionScope, scope ref const(Token) significantToken, size_t cursorPosition)
+{
+    //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
+            || symbolType.name.data == "string") // special case for string
+        {
+            break;
+        }
+        //look at next type to deduce
+        symbolType = symbolType.type;
+    }
+
+
+    return symbolType;
+
+}
+
+// Check if beforeDotSymbol is null or void
+private bool isInvalidForUFCSCompletion(const(DSymbol)* beforeDotSymbol)
+{
+    return beforeDotSymbol is null
+        || beforeDotSymbol.name is getBuiltinTypeName(tok!"void")
+        || (beforeDotSymbol.type !is null && beforeDotSymbol.type.name is getBuiltinTypeName(
+                tok!"void"));
+}
+
+private TokenCursorResult getCursorToken(const(Token)[] tokens, size_t cursorPosition)
+{
+    auto sortedTokens = assumeSorted(tokens);
+    auto sortedBeforeTokens = sortedTokens.lowerBound(cursorPosition);
+
+    TokenCursorResult tokenCursorResult;
+
+    if (sortedBeforeTokens.empty) {
+        return tokenCursorResult;
+    }
+
+    // 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!"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;
+        return tokenCursorResult;
+    }
+    else if (!tokenCursorResult.partialIdentifier.length)
+    {
+        // Check if it's UFCS paren completion
+        size_t index = goBackToOpenParen(sortedBeforeTokens);
+
+        if (index == size_t.max)
+        {
+            return tokenCursorResult;
+        }
+
+        auto slicedAtParen = sortedBeforeTokens[0 .. index];
+        if (slicedAtParen.length >= 4
+            && slicedAtParen[$ - 4].type is tok!"identifier"
+            && slicedAtParen[$ - 3].type is tok!"."
+            && slicedAtParen[$ - 2].type is tok!"identifier"
+            && slicedAtParen[$ - 1].type is tok!"(")
+        {
+            tokenCursorResult.completionContext = CompletionContext.ParenCompletion;
+            tokenCursorResult.significantToken = slicedAtParen[$ - 4];
+            tokenCursorResult.functionName = istring(slicedAtParen[$ - 2].text);
+            return tokenCursorResult;
+        }
+
+    }
+    // if none then it's unknown
+    return tokenCursorResult;
+}
+
+private void getUFCSSymbols(T, Y)(scope ref T localAppender, scope ref Y globalAppender, Scope* completionScope, size_t cursorPosition)
+{
+
+    Scope* currentScope = completionScope.getScopeByCursor(cursorPosition);
+    if (currentScope is null)
+    {
+        return;
+    }
+
+    HashSet!size_t visited;
+
+    while (currentScope !is null && currentScope.parent !is null)
+    {
+        auto localImports = currentScope.symbols.filter!(a => a.kind == CompletionKind.importSymbol);
+        foreach (sym; localImports)
+        {
+            if (sym.type is null)
+                continue;
+            if (sym.qualifier == SymbolQualifier.selectiveImport)
+                localAppender.put(sym.type);
+            else
+                sym.type.getParts(istring(null), localAppender, visited);
+        }
+
+        currentScope = currentScope.parent;
+    }
+
+    if (currentScope is null)
+    {
+        return;
+    }
+    assert(currentScope !is null);
+    assert(currentScope.parent is null);
+
+    foreach (sym; currentScope.symbols)
+    {
+        if (sym.kind != CompletionKind.importSymbol)
+            localAppender.put(sym);
+        else if (sym.type !is null)
+        {
+            if (sym.qualifier == SymbolQualifier.selectiveImport)
+                localAppender.put(sym.type);
+            else
+            {
+                sym.type.getParts(istring(null), globalAppender, visited);
+            }
+        }
+    }
+}
+
+DSymbol*[] getUFCSSymbolsForCursor(Scope* completionScope, scope ref const(Token)[] tokens, size_t cursorPosition)
+{
+    TokenCursorResult tokenCursorResult = getCursorToken(tokens, cursorPosition);
+
+    if (tokenCursorResult.completionContext is CompletionContext.UnknownCompletion)
+    {
+        trace("Is not a valid UFCS completion");
+        return [];
+    }
+
+    const(DSymbol)* deducedSymbolType = deduceSymbolTypeByToken(completionScope, tokenCursorResult.significantToken, cursorPosition);
+
+    if (deducedSymbolType is null)
+    {
+        return [];
+    }
+
+    if (deducedSymbolType.isInvalidForUFCSCompletion)
+    {
+        trace("CursorSymbolType isn't valid for UFCS completion");
+        return [];
+    }
+
+    if (tokenCursorResult.completionContext == CompletionContext.ParenCompletion)
+    {
+        return getUFCSSymbolsForParenCompletion(deducedSymbolType, completionScope, tokenCursorResult.functionName, cursorPosition);
+    }
+    else
+    {
+        return getUFCSSymbolsForDotCompletion(deducedSymbolType, completionScope, cursorPosition, tokenCursorResult.partialIdentifier);
+    }
+
+}
+
+private DSymbol*[] getUFCSSymbolsForDotCompletion(const(DSymbol)* symbolType, Scope* completionScope, size_t cursorPosition, string partial)
+{
+    // local appender
+    FilteredAppender!((DSymbol* a) =>
+            a.isCallableWithArg(symbolType)
+            && toUpper(a.name.data).startsWith(toUpper(partial)),
+        DSymbol*[]) localAppender;
+    // global appender
+    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(const(DSymbol)* symbolType, Scope* completionScope, istring searchWord, size_t cursorPosition)
+{
+    // local appender
+    FilteredAppender!(a => a.isCallableWithArg(symbolType) && a.name.among(searchWord), DSymbol*[]) localAppender;
+    // global appender
+    FilteredAppender!(a => a.isCallableWithArg(symbolType, true) && a.name.among(searchWord), DSymbol*[]) globalAppender;
+
+    getUFCSSymbols(localAppender, globalAppender, completionScope, cursorPosition);
+
+    return localAppender.data ~ globalAppender.data;
+
+}
+
+private bool willImplicitBeUpcasted(scope ref const(DSymbol) incomingSymbolType, scope ref const(DSymbol) significantSymbolType)
+{
+    string fromTypeName = significantSymbolType.name.data;
+    string toTypeName = incomingSymbolType.name.data;
+
+    return typeWillBeUpcastedTo(fromTypeName, toTypeName);
+}
+
+private bool typeWillBeUpcastedTo(string from, string to)
+{
+    while (true)
+    {
+        if (typeWillIntegerUpcastedTo(from, to))
+            return true;
+        if (from.typeIsFloating && to.typeIsFloating)
+            return true;
+
+        if (auto promotionType = from in INTEGER_PROMOTIONS)
+        {
+            if (*promotionType == to)
+                return true;
+            from = *promotionType;
+        }
+        else
+            return false;
+    }
+}
+
+private bool typeWillIntegerUpcastedTo(string from, string to)
+{
+    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;
+    }
+}
+
+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;
+}
+
+/**
+ * Params:
+ *     incomingSymbol = the function symbol to check if it is valid for UFCS with `beforeDotType`.
+ *     beforeDotType = the type of the expression that's used before the dot.
+ *     isGlobalScope = the symbol to check
+ * Returns:
+ *     `true` if `incomingSymbols`' first parameter matches `beforeDotType`
+ *     `false` otherwise
+ */
+bool isCallableWithArg(const(DSymbol)* incomingSymbol, const(DSymbol)* beforeDotType, bool isGlobalScope = false)
+{
+    if (incomingSymbol is null
+        || beforeDotType is null
+        || 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 matchSymbolType(incomingSymbol.functionParameters.front, beforeDotType);
+    }
+    return false;
+}
+
+/// $(D appender) with filter on $(D put)
+struct FilteredAppender(alias predicate, T:
+    T[] = DSymbol*[]) if (__traits(compiles, unaryFun!predicate(T.init) ? 0 : 0))
+{
+    alias pred = unaryFun!predicate;
+    private Appender!(T[]) app;
+
+    void put(T item)
+    {
+        if (pred(item))
+            app.put(item);
+    }
+
+    void put(R)(R items) if (isInputRange!R && __traits(compiles, put(R.init.front)))
+    {
+        foreach (item; items)
+            put(item);
+    }
+
+    void opOpAssign(string op : "~")(T rhs)
+    {
+        put(rhs);
+    }
+
+    alias app this;
+}
+
+@safe pure nothrow unittest
+{
+    FilteredAppender!("a%2", int[]) app;
+    app.put(iota(10));
+    assert(app.data == [1, 3, 5, 7, 9]);
+}
+
+unittest
+{
+    assert(!typeWillBeUpcastedTo("A", "B"));
+    assert(typeWillBeUpcastedTo("bool", "int"));
+}

dsymbol/src/dsymbol/utils.d

@@ -0,0 +1,243 @@
+module dsymbol.utils;
+import dparse.lexer : tok, IdType, Token;
+
+enum TYPE_IDENT_CASES = q{
+	case tok!"int":
+	case tok!"uint":
+	case tok!"long":
+	case tok!"ulong":
+	case tok!"char":
+	case tok!"wchar":
+	case tok!"dchar":
+	case tok!"bool":
+	case tok!"byte":
+	case tok!"ubyte":
+	case tok!"short":
+	case tok!"ushort":
+	case tok!"cent":
+	case tok!"ucent":
+	case tok!"float":
+	case tok!"ifloat":
+	case tok!"cfloat":
+	case tok!"idouble":
+	case tok!"cdouble":
+	case tok!"double":
+	case tok!"real":
+	case tok!"ireal":
+	case tok!"creal":
+	case tok!"this":
+	case tok!"super":
+	case tok!"identifier":
+};
+
+enum STRING_LITERAL_CASES = q{
+	case tok!"stringLiteral":
+	case tok!"wstringLiteral":
+	case tok!"dstringLiteral":
+};
+
+enum TYPE_IDENT_AND_LITERAL_CASES = TYPE_IDENT_CASES ~ STRING_LITERAL_CASES;
+
+/**
+ * Skips blocks of parentheses until the starting block has been closed
+ */
+void skipParen(T)(T tokenSlice, ref size_t i, IdType open, IdType close)
+{
+	if (i >= tokenSlice.length || tokenSlice.length <= 0)
+		return;
+	int depth = 1;
+	while (depth != 0 && i + 1 != tokenSlice.length)
+	{
+		i++;
+		if (tokenSlice[i].type == open)
+			depth++;
+		else if (tokenSlice[i].type == close)
+			depth--;
+	}
+}
+
+
+/**
+ * Skips blocks of parentheses in reverse until the starting block has been opened
+ */
+size_t skipParenReverse(T)(T beforeTokens, size_t i, IdType open, IdType close)
+{
+	if (i == 0)
+		return 0;
+	int depth = 1;
+	while (depth != 0 && i != 0)
+	{
+		i--;
+		if (beforeTokens[i].type == open)
+			depth++;
+		else if (beforeTokens[i].type == close)
+			depth--;
+	}
+	return i;
+}
+
+
+
+size_t skipParenReverseBefore(T)(T beforeTokens, size_t i, IdType open, IdType close)
+{
+	i = skipParenReverse(beforeTokens, i, open, close);
+	if (i != 0)
+		i--;
+	return i;
+}
+
+
+/**
+ * Traverses a token slice in reverse to find the opening parentheses or square bracket
+ * that begins the block the last token is in.
+ */
+size_t goBackToOpenParen(T)(T beforeTokens)
+in
+{
+	assert (beforeTokens.length > 0);
+}
+do
+{
+	size_t i = beforeTokens.length - 1;
+	while (true) switch (beforeTokens[i].type)
+	{
+	case tok!",":
+	case tok!".":
+	case tok!"*":
+	case tok!"&":
+	case tok!"doubleLiteral":
+	case tok!"floatLiteral":
+	case tok!"idoubleLiteral":
+	case tok!"ifloatLiteral":
+	case tok!"intLiteral":
+	case tok!"longLiteral":
+	case tok!"realLiteral":
+	case tok!"irealLiteral":
+	case tok!"uintLiteral":
+	case tok!"ulongLiteral":
+	case tok!"characterLiteral":
+	mixin(TYPE_IDENT_AND_LITERAL_CASES);
+		if (i == 0)
+			return size_t.max;
+		else
+			i--;
+		break;
+	case tok!"(":
+	case tok!"[":
+		return i + 1;
+	case tok!")":
+		i = beforeTokens.skipParenReverseBefore(i, tok!")", tok!"(");
+		break;
+	case tok!"}":
+		i = beforeTokens.skipParenReverseBefore(i, tok!"}", tok!"{");
+		break;
+	case tok!"]":
+		i = beforeTokens.skipParenReverseBefore(i, tok!"]", tok!"[");
+		break;
+	default:
+		return size_t.max;
+	}
+}
+
+///Testing skipping
+unittest
+{
+	Token[] t = [
+		Token(tok!"identifier"), Token(tok!"identifier"), Token(tok!"("),
+		Token(tok!"identifier"), Token(tok!"("), Token(tok!")"), Token(tok!",")
+	];
+	size_t i = t.length - 1;
+	i = skipParenReverse(t, i, tok!")", tok!"(");
+	assert(i == 2);
+	i = t.length - 1;
+	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.22.0",
+    "libdparse": ">=0.23.0 <0.26.0",
     ":common": "*",
     "emsi_containers": "~>0.9.0"
   },

dub.selections.json

@@ -0,0 +1,10 @@
+{
+	"fileVersion": 1,
+	"versions": {
+		"dsymbol": "0.14.1",
+		"emsi_containers": "0.9.0",
+		"libdparse": "0.25.0",
+		"msgpack-d": "1.0.5",
+		"stdx-allocator": "2.77.5"
+	}
+}

libdparse

@@ -1 +1 @@
-Subproject commit 592ef39a73a58439afc75a3e6c13a0d87d0b847d
+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)
@@ -396,7 +425,8 @@ void printCompletionResponse(ref const AutocompleteResponse response, bool exten
 						completion.kind == char.init ? "" : "" ~ completion.kind,
 						completion.definition,
 						completion.symbolFilePath.length ? completion.symbolFilePath ~ " " ~ completion.symbolLocation.to!string : "",
-						completion.documentation
+						completion.documentation,
+						completion.typeOf
 					));
 				else
 					app.put(makeTabSeparated(completion.identifier, "" ~ completion.kind));

src/dcd/server/autocomplete/complete.d

@@ -28,9 +28,9 @@ import std.path;
 import std.range : assumeSorted;
 import std.string;
 import std.typecons;
+import std.exception : enforce;
 
 import dcd.server.autocomplete.util;
-import dcd.server.autocomplete.ufcs;
 
 import dparse.lexer;
 import dparse.rollback_allocator;
@@ -42,10 +42,19 @@ import dsymbol.modulecache;
 import dsymbol.scope_;
 import dsymbol.string_interning;
 import dsymbol.symbol;
+import dsymbol.ufcs;
+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:
@@ -127,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);
 }
@@ -204,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!"]":
@@ -219,7 +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);
+			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!":":
@@ -233,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;
@@ -241,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
@@ -250,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;
@@ -303,9 +318,16 @@ 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.
+			response.completionType = CompletionType.calltips;
+		}
 		break;
 	default:
 		break;
@@ -313,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.:
  * ---
@@ -496,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 = [])
@@ -558,10 +643,12 @@ void setCompletions(T)(ref AutocompleteResponse response,
 	DSymbol*[] symbols = getSymbolsByTokenChain(completionScope, tokens,
 		cursorPosition, completionType);
 
-	if (tokens.length > 2 && tokens[1] == tok!".")
+	// If calltipHint is templateArguments we ensure that the symbol is also templated
+	if (callTipHint == CalltipHint.templateArguments
+		&& symbols.length >= 1
+		&& symbols[0].qualifier != SymbolQualifier.templated)
 	{
-		symbols.getUFCSParenCompletion(completionScope, stringToken(tokens[0]), stringToken(
-				tokens[2]), cursorPosition);
+		return;
 	}
 
 	if (symbols.length == 0)
@@ -581,10 +668,10 @@ void setCompletions(T)(ref AutocompleteResponse response,
 		}
 		addSymToResponse(symbols[0], response, partial, completionScope);
 		response.completionType = CompletionType.identifiers;
-		lookupUFCS(completionScope, symbols[0], cursorPosition, 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,8 @@ 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/ufcs.d

@@ -1,193 +0,0 @@
-module dcd.server.autocomplete.ufcs;
-
-import dcd.server.autocomplete.util;
-import dsymbol.symbol;
-import dsymbol.scope_;
-import dcd.common.messages;
-import std.functional : unaryFun;
-import std.algorithm;
-import std.array;
-import std.range;
-import dsymbol.builtin.names;
-import std.string;
-import dparse.lexer : tok;
-import std.regex;
-import containers.hashset : HashSet;
-
-void lookupUFCS(Scope* completionScope, DSymbol* beforeDotSymbol, size_t cursorPosition, ref AutocompleteResponse response)
-{
-    // UFCS completion
-    DSymbol*[] ufcsSymbols = getSymbolsForUFCS(completionScope, beforeDotSymbol, cursorPosition);
-    response.completions ~= map!(s => createCompletionForUFCS(s))(ufcsSymbols).array;
-}
-
-AutocompleteResponse.Completion createCompletionForUFCS(const DSymbol* symbol)
-{
-    return AutocompleteResponse.Completion(symbol.name, CompletionKind.ufcsName, symbol.callTip, symbol
-            .symbolFile, symbol
-            .location, symbol
-            .doc);
-}
-
-// Check if beforeDotSymbol is null or void
-bool isInvalidForUFCSCompletion(const(DSymbol)* beforeDotSymbol)
-{
-    return beforeDotSymbol is null
-        || beforeDotSymbol.name is getBuiltinTypeName(tok!"void")
-        || (beforeDotSymbol.type !is null && beforeDotSymbol.type.name is getBuiltinTypeName(
-                tok!"void"));
-}
-/**
- * Get symbols suitable for UFCS.
- *
- * a symbol is suitable for UFCS if it satisfies the following:
- * $(UL
- *  $(LI is global or imported)
- *  $(LI is callable with $(D beforeDotSymbol) as it's first argument)
- * )
- *
- * Params:
- *     completionScope = current scope
- *     beforeDotSymbol = the symbol before the dot (implicit first argument to UFCS function)
- *     cursorPosition = current position
- * Returns:
- *     callable an array of symbols suitable for UFCS at $(D cursorPosition)
- */
-DSymbol*[] getSymbolsForUFCS(Scope* completionScope, const(DSymbol)* beforeDotSymbol, size_t cursorPosition)
-{
-    if (beforeDotSymbol.isInvalidForUFCSCompletion)
-    {
-        return null;
-    }
-
-    Scope* currentScope = completionScope.getScopeByCursor(cursorPosition);
-    assert(currentScope);
-    HashSet!size_t visited;
-
-    // local appender
-    FilteredAppender!(a => a.isCallableWithArg(beforeDotSymbol), DSymbol*[]) localAppender;
-
-    while (currentScope !is null && currentScope.parent !is null)
-    {
-        auto localImports = currentScope.symbols.filter!(a => a.kind == CompletionKind.importSymbol);
-        foreach (sym; localImports)
-        {
-            if (sym.type is null)
-                continue;
-            if (sym.qualifier == SymbolQualifier.selectiveImport)
-                localAppender.put(sym.type);
-            else
-                sym.type.getParts(internString(null), localAppender, visited);
-        }
-
-        currentScope = currentScope.parent;
-    }
-
-    // global appender
-    FilteredAppender!(a => a.isCallableWithArg(beforeDotSymbol, true), DSymbol*[]) globalAppender;
-
-    // global symbols and global imports
-    assert(currentScope !is null);
-    assert(currentScope.parent is null);
-    foreach (sym; currentScope.symbols)
-    {
-        if (sym.kind != CompletionKind.importSymbol)
-            localAppender.put(sym);
-        else if (sym.type !is null)
-        {
-            if (sym.qualifier == SymbolQualifier.selectiveImport)
-                localAppender.put(sym.type);
-            else
-            {
-                sym.type.getParts(istring(null), globalAppender, visited);
-            }
-        }
-    }
-    return localAppender.opSlice ~ globalAppender.opSlice;
-}
-
-/**
- * Params:
- *     incomingSymbol = the function symbol to check if it is valid for UFCS with `beforeDotType`.
- *     beforeDotType = the type of the expression that's used before the dot.
- *     isGlobalScope = the symbol to check
- * Returns:
- *     `true` if `incomingSymbols`' first parameter matches `beforeDotType`
- *     `false` otherwise
- */
-bool isCallableWithArg(const(DSymbol)* incomingSymbol, const(DSymbol)* beforeDotType, bool isGlobalScope = false)
-{
-    if (!incomingSymbol || !beforeDotType
-        || (isGlobalScope && incomingSymbol.protection == tok!"private"))
-    {
-        return false;
-    }
-
-    if (incomingSymbol.kind == CompletionKind.functionName && !incomingSymbol
-        .functionParameters.empty)
-    {
-        return incomingSymbol.functionParameters.front.type is beforeDotType;
-    }
-
-    return false;
-}
-
-/// $(D appender) with filter on $(D put)
-struct FilteredAppender(alias predicate, T:
-    T[] = DSymbol*[]) if (__traits(compiles, unaryFun!predicate(T.init) ? 0 : 0))
-{
-    alias pred = unaryFun!predicate;
-    private Appender!(T[]) app;
-
-    void put(T item)
-    {
-        if (pred(item))
-            app.put(item);
-    }
-
-    void put(R)(R items) if (isInputRange!R && __traits(compiles, put(R.init.front)))
-    {
-        foreach (item; items)
-            put(item);
-    }
-
-    void opOpAssign(string op : "~")(T rhs)
-    {
-        put(rhs);
-    }
-
-    alias app this;
-}
-
-@safe pure nothrow unittest
-{
-    FilteredAppender!("a%2", int[]) app;
-    app.put(iota(10));
-    assert(app.data == [1, 3, 5, 7, 9]);
-}
-
-bool doUFCSSearch(string beforeToken, string lastToken)
-{
-    // we do the search if they are different from eachother
-    return beforeToken != lastToken;
-}
-
-void getUFCSParenCompletion(ref DSymbol*[] symbols, Scope* completionScope, istring firstToken, istring nextToken, size_t cursorPosition)
-{
-    DSymbol* firstSymbol = completionScope.getFirstSymbolByNameAndCursor(firstToken, cursorPosition);
-
-    if (firstSymbol is null)
-        return;
-
-    DSymbol*[] possibleUFCSSymbol = completionScope.getSymbolsByNameAndCursor(nextToken, cursorPosition);
-    foreach(nextSymbol; possibleUFCSSymbol){
-        if (nextSymbol && nextSymbol.functionParameters)
-        {
-            if (nextSymbol.isCallableWithArg(firstSymbol.type))
-            {
-                nextSymbol.kind = CompletionKind.ufcsName;
-                symbols ~= nextSymbol;
-            }
-        }
-    }
-}

src/dcd/server/autocomplete/util.d

@@ -37,7 +37,8 @@ import dsymbol.modulecache;
 import dsymbol.scope_;
 import dsymbol.string_interning;
 import dsymbol.symbol;
-import dcd.server.autocomplete.ufcs;
+import dsymbol.ufcs;
+import dsymbol.utils;
 
 enum ImportKind : ubyte
 {
@@ -146,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);
 	}
@@ -380,7 +382,8 @@ DSymbol*[] getSymbolsByTokenChain(T)(Scope* completionScope,
 		case tok!"[":
 			if (symbols.length == 0)
 				break loop;
-			if (symbols[0].qualifier == SymbolQualifier.array)
+			if (symbols[0].qualifier == SymbolQualifier.array
+				|| symbols[0].qualifier == SymbolQualifier.pointer)
 			{
 				skip(tok!"[", tok!"]");
 				if (!isSliceExpression(tokens, i))
@@ -420,133 +423,6 @@ DSymbol*[] getSymbolsByTokenChain(T)(Scope* completionScope,
 	return symbols;
 }
 
-enum TYPE_IDENT_CASES = q{
-	case tok!"int":
-	case tok!"uint":
-	case tok!"long":
-	case tok!"ulong":
-	case tok!"char":
-	case tok!"wchar":
-	case tok!"dchar":
-	case tok!"bool":
-	case tok!"byte":
-	case tok!"ubyte":
-	case tok!"short":
-	case tok!"ushort":
-	case tok!"cent":
-	case tok!"ucent":
-	case tok!"float":
-	case tok!"ifloat":
-	case tok!"cfloat":
-	case tok!"idouble":
-	case tok!"cdouble":
-	case tok!"double":
-	case tok!"real":
-	case tok!"ireal":
-	case tok!"creal":
-	case tok!"this":
-	case tok!"super":
-	case tok!"identifier":
-};
-
-enum STRING_LITERAL_CASES = q{
-	case tok!"stringLiteral":
-	case tok!"wstringLiteral":
-	case tok!"dstringLiteral":
-};
-
-enum TYPE_IDENT_AND_LITERAL_CASES = TYPE_IDENT_CASES ~ STRING_LITERAL_CASES;
-
-/**
- *
- */
-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.
  */
@@ -647,128 +523,67 @@ bool isUdaExpression(T)(ref T tokens)
 	return result;
 }
 
-/**
- * Traverses a token slice in reverse to find the opening parentheses or square bracket
- * that begins the block the last token is in.
- */
-size_t goBackToOpenParen(T)(T beforeTokens)
-in
-{
-	assert (beforeTokens.length > 0);
-}
-do
-{
-	size_t i = beforeTokens.length - 1;
-	while (true) switch (beforeTokens[i].type)
-	{
-	case tok!",":
-	case tok!".":
-	case tok!"*":
-	case tok!"&":
-	case tok!"doubleLiteral":
-	case tok!"floatLiteral":
-	case tok!"idoubleLiteral":
-	case tok!"ifloatLiteral":
-	case tok!"intLiteral":
-	case tok!"longLiteral":
-	case tok!"realLiteral":
-	case tok!"irealLiteral":
-	case tok!"uintLiteral":
-	case tok!"ulongLiteral":
-	case tok!"characterLiteral":
-	mixin(TYPE_IDENT_AND_LITERAL_CASES);
-		if (i == 0)
-			return size_t.max;
-		else
-			i--;
-		break;
-	case tok!"(":
-	case tok!"[":
-		return i + 1;
-	case tok!")":
-		i = beforeTokens.skipParenReverseBefore(i, tok!")", tok!"(");
-		break;
-	case tok!"}":
-		i = beforeTokens.skipParenReverseBefore(i, tok!"}", tok!"{");
-		break;
-	case tok!"]":
-		i = beforeTokens.skipParenReverseBefore(i, tok!"]", tok!"[");
-		break;
-	default:
-		return size_t.max;
-	}
-}
-
-/**
- * Skips blocks of parentheses until the starting block has been closed
- */
-void skipParen(T)(T tokenSlice, ref size_t i, IdType open, IdType close)
-{
-	if (i >= tokenSlice.length || tokenSlice.length <= 0)
-		return;
-	int depth = 1;
-	while (depth != 0 && i + 1 != tokenSlice.length)
-	{
-		i++;
-		if (tokenSlice[i].type == open)
-			depth++;
-		else if (tokenSlice[i].type == close)
-			depth--;
-	}
-}
-
-/**
- * Skips blocks of parentheses in reverse until the starting block has been opened
- */
-size_t skipParenReverse(T)(T beforeTokens, size_t i, IdType open, IdType close)
-{
-	if (i == 0)
-		return 0;
-	int depth = 1;
-	while (depth != 0 && i != 0)
-	{
-		i--;
-		if (beforeTokens[i].type == open)
-			depth++;
-		else if (beforeTokens[i].type == close)
-			depth--;
-	}
-	return i;
-}
-
-size_t skipParenReverseBefore(T)(T beforeTokens, size_t i, IdType open, IdType close)
-{
-	i = skipParenReverse(beforeTokens, i, open, close);
-	if (i != 0)
-		i--;
-	return i;
-}
-
-///
-unittest
-{
-	Token[] t = [
-		Token(tok!"identifier"), Token(tok!"identifier"), Token(tok!"("),
-		Token(tok!"identifier"), Token(tok!"("), Token(tok!")"), Token(tok!",")
-	];
-	size_t i = t.length - 1;
-	i = skipParenReverse(t, i, tok!")", tok!"(");
-	assert(i == 2);
-	i = t.length - 1;
-	i = skipParenReverseBefore(t, i, tok!")", tok!"(");
-	assert(i == 1);
-}
-
 AutocompleteResponse.Completion makeSymbolCompletionInfo(const DSymbol* symbol, char kind)
 {
-	string definition;
-	if ((kind == CompletionKind.variableName || kind == CompletionKind.memberVariableName) && symbol.type)
-		definition = symbol.type.name ~ ' ' ~ symbol.name;
-	else if (kind == CompletionKind.enumMember)
-		definition = symbol.name; // TODO: add enum value to definition string
-	else
-		definition = symbol.callTip;
-	// TODO: definition strings could include more information, like on classes inheritance
-	return AutocompleteResponse.Completion(symbol.name, kind, definition,
+	auto ret = AutocompleteResponse.Completion(symbol.name, kind, null,
 		symbol.symbolFile, symbol.location, symbol.doc);
+
+	if (symbol.type)
+		ret.typeOf = symbol.type.formatType;
+
+	if ((kind == CompletionKind.variableName || kind == CompletionKind.memberVariableName) && symbol.type)
+	{
+		if (symbol.type.kind == CompletionKind.functionName && !ret.typeOf.length)
+			ret.definition = symbol.type.name ~ ' ' ~ symbol.name;
+		else
+			ret.definition = ret.typeOf ~ ' ' ~ symbol.name;
+	}
+	else if (kind == CompletionKind.enumMember)
+		ret.definition = symbol.name; // TODO: add enum value to definition string
+	else
+		ret.definition = symbol.callTip;
+
+	// TODO: extend completion with more info such as class inheritance
+	return ret;
+}
+
+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/tc059/expected1.txt

@@ -1,4 +1,5 @@
 identifiers
-libraryFunction	f	Tuple!long libraryFunction(string s, string s2)	stdin 190	foobar
-libraryFunction	f	int* libraryFunction(string s)	stdin 99	Hello\nWorld
-libraryVariable	v	int libraryVariable	stdin 56	My variable
+libraryFunction	f	Tuple!long libraryFunction(string s, string s2)	stdin 223	foobar	
+libraryFunction	f	int* libraryFunction(string s)	stdin 132	Hello\nWorld	int*
+libraryVariable	v	int libraryVariable	stdin 56	My variable	int
+libraryVariable2	v	int* libraryVariable2	stdin 88	My variable	int*

tests/tc059/file.d

@@ -5,6 +5,8 @@ void main(string[] args)
 
 /// My variable
 int libraryVariable;
+/// ditto
+int* libraryVariable2;
 
 /// Hello
 /// World

tests/tc061/expected1.txt

@@ -1,3 +1,3 @@
 calltips
-libraryFunction		Tuple!long libraryFunction(string s, string s2)	stdin 166	foobar
-libraryFunction		int* libraryFunction(string s)	stdin 75	Hello\nWorld
+libraryFunction		Tuple!long libraryFunction(string s, string s2)	stdin 166	foobar	
+libraryFunction		int* libraryFunction(string s)	stdin 75	Hello\nWorld	int*

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_calltip_in_func/file.d

@@ -0,0 +1,14 @@
+class Bar
+{
+	void fun(A param)
+	{
+	}
+}
+
+class Foo
+{
+	void foo(Bar bar)
+	{
+		bar.fun(
+	}
+}

tests/tc_calltip_in_func/run.sh

@@ -1,5 +1,5 @@
 set -e
 set -u
 
-../../bin/dcd-client $1 -c66 <<< "class Bar{void fun(A param){}}class Foo{void foo(Bar bar){bar.fun(}}" > actual.txt
+../../bin/dcd-client $1 file.d -c84 > 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_extended_ditto/expected1.txt

@@ -1,3 +1,3 @@
 identifiers
-foo	f	void foo()	stdin 26	my documentation
-foo	f	void foo(int i)	stdin 49	my documentation
+foo	f	void foo()	stdin 26	my documentation	void
+foo	f	void foo(int i)	stdin 49	my documentation	void

tests/tc_extended_types/expected1.txt

@@ -0,0 +1,2 @@
+identifiers
+bar	v	foo bar	stdin 92		

tests/tc_extended_types/file.d

@@ -0,0 +1,12 @@
+/// my documentation
+struct S
+{
+	T foo(T)() { return T.init; }
+}
+
+void test()
+{
+	S s;
+	auto bar = s.foo!int();
+	bar
+}

tests/tc_extended_types/run.sh

@@ -0,0 +1,5 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d -x -c115 > actual1.txt
+diff actual1.txt expected1.txt --strip-trailing-cr

tests/tc_import_symbol_list/run.sh

@@ -2,5 +2,5 @@ set -e
 set -u
 
 ../../bin/dcd-client $1 file.d --extended -I"$PWD"/newpackage -c$(wc -c < file.d) > actual1.txt
-echo -e "identifiers\nSomeStruct\ts\t\t$PWD/newpackage/newmodule.d 26\t" > expected1.txt
+echo -e "identifiers\nSomeStruct\ts\t\t$PWD/newpackage/newmodule.d 26\t\t" > expected1.txt
 diff actual1.txt expected1.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_pointer_type_printing/expected1.txt

@@ -0,0 +1,14 @@
+identifiers
+itemA	v	S itemA	stdin 44		S
+itemB	v	S* itemB	stdin 55		S*
+itemC	v	S[]* itemC	stdin 68		S[]*
+itemD	v	S[][]* itemD	stdin 83		S[][]*
+itemE	v	S[][]*[] itemE	stdin 100		S[][]*[]
+itemF	v	S[][]*[][] itemF	stdin 119		S[][]*[][]
+itemG	v	S[][...]*[][] itemG	stdin 141		S[][...]*[][]
+itemH	v	S[][]*[...][] itemH	stdin 163		S[][]*[...][]
+itemI	v	S[...][]*[...][] itemI	stdin 188		S[...][]*[...][]
+itemJ	v	S[...]*[]*[...][] itemJ	stdin 214		S[...]*[]*[...][]
+itemK	v	S[...]*[]**[...][] itemK	stdin 241		S[...]*[]**[...][]
+itemL	v	S[...]*[]*[...]*[] itemL	stdin 268		S[...]*[]*[...]*[]
+itemM	v	S[...]*[]*[...]*[]* itemM	stdin 296		S[...]*[]*[...]*[]*

tests/tc_pointer_type_printing/file.d

@@ -0,0 +1,23 @@
+struct S
+{
+	int member;
+}
+
+void test()
+{
+	S itemA;
+	S* itemB;
+	S[]* itemC;
+	S[][]* itemD;
+	S[][]*[] itemE;
+	S[][]*[][] itemF;
+	S[][int]*[][] itemG;
+	S[][]*[int][] itemH;
+	S[int][]*[int][] itemI;
+	S[int]*[]*[int][] itemJ;
+	S[int]*[]**[int][] itemK;
+	S[int]*[]*[int]*[] itemL;
+	S[int]*[]*[int]*[]* itemM;
+
+	item
+}

tests/tc_pointer_type_printing/run.sh

@@ -0,0 +1,5 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d -x -c309 > actual1.txt
+diff actual1.txt expected1.txt --strip-trailing-cr

tests/tc_pointers/expected1.txt

@@ -0,0 +1,30 @@
+identifiers
+alignof	k				
+init	k				
+mangleof	k				
+member	v	int member	stdin 16		int
+sizeof	k				
+stringof	k				
+tupleof	k				
+identifiers
+alignof	k				
+init	k				
+mangleof	k				
+member	v	int member	stdin 16		int
+sizeof	k				
+stringof	k				
+tupleof	k				
+identifiers
+alignof	k				
+init	k				
+mangleof	k				
+sizeof	k				
+stringof	k				
+identifiers
+alignof	k				
+init	k				
+mangleof	k				
+member	v	int member	stdin 16		int
+sizeof	k				
+stringof	k				
+tupleof	k				

tests/tc_pointers/file.d

@@ -0,0 +1,28 @@
+struct S
+{
+	int member;
+}
+
+void test()
+{
+	S itemA;
+	itemA.
+}
+
+void test2()
+{
+	S* itemPtr = &itemA;
+	itemPtr.
+}
+
+void test3()
+{
+	S** itemPtrPtr = &itemA;
+	itemPtrPtr.
+}
+
+void test3()
+{
+	S** itemPtrPtr = &itemA;
+	itemPtrPtr[10].
+}

tests/tc_pointers/run.sh

@@ -0,0 +1,8 @@
+set -e
+set -u
+
+../../bin/dcd-client $1 file.d -x -c58 > actual1.txt
+../../bin/dcd-client $1 file.d -x -c108 >> actual1.txt
+../../bin/dcd-client $1 file.d -x -c165 >> actual1.txt
+../../bin/dcd-client $1 file.d -x -c226 >> actual1.txt
+diff actual1.txt expected1.txt --strip-trailing-cr

tests/tc_recursive_public_import/app.d

@@ -0,0 +1 @@
+import testing; void main() { Hello hello; hello.w }

tests/tc_recursive_public_import/run.sh

@@ -0,0 +1,8 @@
+set -e
+set -u
+
+echo "import: $PWD/testing"
+
+../../bin/dcd-client $1 app.d --extended -I $PWD/ -c50 > actual.txt
+echo -e "identifiers\nworld\tv\tWorld world\t$PWD/testing/a.d 77\t\tWorld" > expected.txt
+diff actual.txt expected.txt --strip-trailing-cr

tests/tc_recursive_public_import/testing/a.d

@@ -0,0 +1,11 @@
+module testing.a;
+
+import testing;
+
+struct Fuck {}
+
+struct Hello
+{
+    World world;
+    Fuck fuck;
+}

tests/tc_recursive_public_import/testing/b.d

@@ -0,0 +1,8 @@
+module testing.b;
+
+import testing;
+
+struct World
+{
+    int field;
+}

tests/tc_recursive_public_import/testing/package.d

@@ -0,0 +1,4 @@
+module testing;
+
+public import testing.a;
+public import testing.b;

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].
+}
+