Release 0.24.0

Add eval to Expr/TypedExpr.
Update badges
2021-06-02 10:23:41 +02:00 · 2021-06-02 10:21:41 +02:00 · 2021-05-22 12:07:27 +08:00 · 2021-05-14 21:33:09 +08:00 · 2021-05-14 21:29:25 +08:00 · 2021-05-03 20:38:55 +02:00
47 changed files with 1752 additions and 679 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,96 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        haxe-version:
+          - "3.4.7"
+          - stable
+          - nightly
+        target: 
+          - node
+
+    steps:
+    - name: Check out repo
+      uses: actions/checkout@v2
+    
+    - name: Get yarn cache directory path
+      id: yarn-cache-dir-path
+      run: echo "::set-output name=dir::$(yarn cache dir)"
+
+    - name: Cache Yarn
+      uses: actions/cache@v1
+      with:
+        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-yarn-
+        
+    - name: Cache Haxe
+      uses: actions/cache@v1
+      with:
+        path: ~/haxe
+        key: haxe
+        
+    - name: Install Lix
+      uses: lix-pm/setup-lix@master
+      
+    - name: Install Haxe
+      run: lix install haxe ${{ matrix.haxe-version }}
+    
+    - name: Install Haxe Libraries
+      run: lix download
+      
+    - name: Run Test
+      run: lix run travix ${{ matrix.target }}
+
+  release:
+    runs-on: ubuntu-latest
+    needs: test
+    if: startsWith(github.ref, 'refs/tags/') # consider using the "release" event. see: https://docs.github.com/en/actions/reference/events-that-trigger-workflows#release
+    
+    steps:
+    - name: Check out repo
+      uses: actions/checkout@v2
+    
+    - name: Get yarn cache directory path
+      id: yarn-cache-dir-path
+      run: echo "::set-output name=dir::$(yarn cache dir)"
+
+    - name: Cache Yarn
+      uses: actions/cache@v1
+      with:
+        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
+        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-yarn-
+        
+    - name: Cache Haxe
+      uses: actions/cache@v1
+      with:
+        path: ~/haxe
+        key: haxe
+        
+    - name: Install Lix
+      uses: lix-pm/setup-lix@master
+      
+    - name: Install Haxe
+      run: lix install haxe stable
+    
+    - name: Install Haxe Libraries
+      run: lix download
+      
+    - name: Release to Haxelib
+      run: lix run travix release
+      env:
+        HAXELIB_AUTH: ${{ secrets.HAXELIB_AUTH }}
+    
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/bin
--- a/.haxerc
+++ b/.haxerc
@@ -0,0 +1,4 @@
+{
+  "version": "4.2.1",
+  "resolveLibs": "scoped"
+}
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,19 +0,0 @@
-sudo: required
-dist: trusty
-
-language: haxe
-
-haxe:
-  - "3.2.1"
-  - development
-  
-matrix:
-  allow_failures:
-    - haxe: development
-    
-install:
-  - haxelib install travix
-  - haxelib run travix install
-
-script:
-  - haxelib run travix node
--- a/.travis.yml.disabled
+++ b/.travis.yml.disabled
@@ -0,0 +1,41 @@
+sudo: required
+dist: xenial
+
+stages:
+  - test
+  - deploy
+
+language: node_js
+node_js: 8
+
+os:
+  - linux
+  # - osx
+
+env:
+  - HAXE_VERSION=3.4.7
+  - HAXE_VERSION=edge
+
+install:
+  - npm i -g lix@15.5.4
+  - lix install haxe $HAXE_VERSION
+  - lix download
+
+script:
+  - lix run travix node
+
+jobs:
+  include:
+    # - stage: test # should uncomment this when there is no matrix above (e.g. only one os, one env, etc)
+    - stage: deploy
+      language: haxe
+      haxe: "3.4.7"
+      os: linux
+      install: skip
+      script: skip
+      env:
+        secure: T4SCtY5qmEsK1ARWPevJmqLm23tv4CobLrbPOQV3FsoQno7FCP1S/+9GmuoJKzeTjWMzdTeDsp8TVwZ6AyGjvhl2nZNjhU+QTsir4tfbYYRyvsz/QK6pveFbPQVv7OsnnaB4wbZtqGZ8mzFeQf7Ol4tsNe7iUFJb/iVc+4/lUxo=
+      after_success:
+        - haxelib install travix
+        - haxelib run travix install
+        - haxelib run travix release
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -0,0 +1,19 @@
+{
+    "version": "2.0.0",
+    "command": "haxelib",
+    "args": ["run", "travix", "node"],
+    "problemMatcher": "$haxe",
+    "tasks": [
+        {
+            "label": "haxelib",
+            "command": "haxelib",
+            "args": [
+                "run",
+                "travix",
+                "node"
+            ],
+            "problemMatcher": "$haxe",
+            "group": "build"
+        }
+    ]
+}
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 # Tinkerbell Macro Library
-[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg?maxAge=2592000)](https://gitter.im/haxetink/public)
+
+[![Build Status](https://github.com/haxetink/tink_macro/actions/workflows/ci.yml/badge.svg)](https://github.com/haxetink/tink_macro/actions)
+[![Gitter](https://img.shields.io/gitter/room/haxetink/public?logo=gitter&)](https://gitter.im/haxetink/public)
+[![Discord](https://img.shields.io/discord/162395145352904705.svg?logo=discord)](https://discord.com/channels/162395145352904705/579634919576436736)
+

 Explained in current marketing speak, `tink_macro` is *the* macro toolkit ;)

@@ -15,18 +19,17 @@ The library is build on top of the haxe macro API and `tink_core`, having three

 <!-- START INDEX -->
 - [Macro API](#macro-api)
-	- 
-		- [Expression Tools](#expression-tools)
-			- [Basic Helpers](#basic-helpers)
-			- [Extracting Constants](#extracting-constants)
-			- [Shortcuts](#shortcuts)
-			- [Type Inspection](#type-inspection)
-			- [Advanced Transformations](#advanced-transformations)
-		- [Position Tools](#position-tools)
-		- [Type Tools](#type-tools)
-		- [Function Tools](#function-tools)
-		- [Operation Tools](#operation-tools)
-		- [Metadata Tools](#metadata-tools)
+	- [Expression Tools](#expression-tools)
+		- [Basic Helpers](#basic-helpers)
+		- [Extracting Constants](#extracting-constants)
+		- [Shortcuts](#shortcuts)
+		- [Type Inspection](#type-inspection)
+		- [Advanced Transformations](#advanced-transformations)
+	- [Position Tools](#position-tools)
+	- [Type Tools](#type-tools)
+	- [Function Tools](#function-tools)
+	- [Operation Tools](#operation-tools)
+	- [Metadata Tools](#metadata-tools)
 - [Build Infrastructure](#build-infrastructure)
 	- [Member](#member)
 	- [ClassBuilder](#classbuilder)
@@ -49,9 +52,9 @@ It is suggested to use this API by `using tink.MacroApi;`

 Apart form `tink_macro` specific things, it will also use `haxe.macro.ExprTools` and `tink.core.Outcome`.

-### Expression Tools
+## Expression Tools

-#### Basic Helpers
+### Basic Helpers

 - `at(e:ExprDef, ?pos:Position):Expr`  
 A short hand for creating expression as for example `EReturn(value).at(position)`, instead of the more verbose `{ expr: EReturn(value), pos: position }`.
@@ -67,7 +70,7 @@ Traces the string representation of an expression and returns it.
 - `concat(e1:Expr, e2:Expr):Expr`
 Concats two expressions into a block. If either sub-expression is a block itself, it gets flattened into the resulting block.

-#### Extracting Constants
+### Extracting Constants

 - `isWildcard(e:Expr):Bool`  
 Checks whether an expression is the identifier `_`
@@ -80,7 +83,7 @@ Attempts extracting an identifier from an expression. Note that an identifier ca
 - `getName(e:Expr):Outcome<String, tink.core.Error>`  
 Attempts extracting a name, i.e. a string constant or identifier from an expression

-#### Shortcuts
+### Shortcuts

 Often reification is prefereable to these shortcuts - if applicable. Unlike reification, the position of these expressions will default to `Context.currentPos()` rather than the position where they were created.

@@ -117,7 +120,7 @@ Generates a simple if statement.
 - `iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position):Expr`  
 Will loop over `target` with a loop variable called `loopVar` using `body`-

-#### Type Inspection
+### Type Inspection

 - `is(e:Expr, c:ComplexType):Bool`  
 Tells you whether a given expression has a given type. 
@@ -127,7 +130,7 @@ Inspects, whether an expression can be iterated over and if so returns the eleme
 - `typeof(expr:Expr, ?locals:Array<Var>):Outcome<Type, tink.core.Error>`  
 Attempts to determine the type of an expression. Note that you can use `locals` to hint the compiler the type of certain identifiers. For example if you are in a build macro, and you want to get the type of a subexpression of a method body, you could "fake" the other members of the class as local variables, because in that context, the other members do not yet exists from the compiler's perspective.

-#### Advanced Transformations
+### Advanced Transformations

 - `has(e:Expr, condition:Expr->Bool, ?options: { ?enterFunctions: Bool })`
 This function actually does no transformation, but is very close to the rest of these functions. It allows you to check whether an expression has a sub-expression that satisfies `condition`. By default, it does not enter nested functions. 
@@ -185,7 +188,7 @@ This will traverse an expression and will apply the `yielder` to the "leafs", wh

 	If you set `options.leaveLoops` to `true`, then loops (both for and while) will be considered leafs. 
 	
-### Position Tools
+## Position Tools

 - `sanitize(pos:Position):Position`  
 Returns the position ITself or `Context.currentPos()` if it's null.
@@ -200,7 +203,7 @@ Creates a failed `Outcome` associated with the supplied position.
 - `getOutcome<D, F>(pos:Position, outcome:Outcome<D, F>):D`  
 Attempts getting the result of the supplied outcome. If it is a failure, it will cause an error at the given position.

-### Type Tools
+## Type Tools

 - `getID(t:Type, ?reduced = true):Null<String>`  
 Returns a String identifier for a type if available. By default, the type will be reduced prior to getting its name (typedefs are resolved etc.). With `reduced = false` you can also get the name of a typedef.
@@ -223,7 +226,7 @@ Will tell you whether a field is a variable or not. Signature is likely to chang
 - `toComplex(type:Type, ?option:{ ?direct: Bool }):ComplexType`  
 Will convert a `Type` to a `ComplexType`. Ideally this is done with `Context.toComplexType` but for monomorphs and the like, this builtin method fails and `tink_macro` uses a hack to make it work none the less. You can also use `{ direct : true }` to force this hack in case the translation fails (which can be the case with private types).

-### Function Tools
+## Function Tools

 - `asExpr(f:Function, ?name:String, ?pos:Position):Expr`  
 Converts a function to an expression, i.e. a local function definition.
@@ -234,7 +237,7 @@ A shorthand to create function arguments.
 - `getArgIdents(f:Function):Array<Expr>`  
 Will extract the argument list of a function as an expression list of identifiers (usefull when writing call-forwarding macros or the like).

-### Operation Tools
+## Operation Tools

 - `get(o:Binop, e:Expr):Outcome<{ e1:Expr, e2:Expr, pos:Position }, tink.core.Error>`  
 Attempts to extract a specific binary operation from an expression.
@@ -248,7 +251,7 @@ Attempts to extract a specific unary operation from an expression.
 - `getUnop(e:Expr):Outcome<{ op:Unop, e:Expr, postFix:Bool, pos:Position }, tink.core.Error>`  
 Attempts to decompose an expression into the parts of a unary operation.

-### Metadata Tools
+## Metadata Tools

 - `toMap(m:Metadata):Map<String, Array<Array<Expr>>`
 Will deconstruct an array of metadata tags to a `Map` mapping the tag names to an array of the argument lists of each tag with that name. So `@foo(1) @foo(2) @bar` becomes `["foo" => [[1], [2]], "bar" => [[]]]`
@@ -301,7 +304,7 @@ abstract Member from Field to Field {

 Most of the API should be self-explaining. The `isBound` property is a bad name to convey the concept that a field can be either `inline` (`true`) or `dynamic` (`false`) or neither (`null`). Equally, `isPublic` is nullable which means that normally defaults to `private`.

-The `publish` method will make a field `public` if it is not `private`. This can also be done with `if (m.isPublic == null) m.isPublic = true;` but the implementation is far more efficient - for what its worth.
+The `publish` method will make a field `public` if it is not explicitly marked as `private`. This can also be done with `if (m.isPublic == null) m.isPublic = true;` but the implementation is far more efficient - for what its worth.

 The `extractMeta` method will "peel of" the first tag with a given `name` - if available. Note that the tag will be removed from the member.

@@ -389,7 +392,7 @@ The `init` method is the swiss army knife of initializing fields. The `options.p

 #### Setter Bypass

-It is important to know that when you initialize a field with `options.bypass` set to true, existing setters will by bypassed. That's particularly helpful if your setter triggers a side effect that you don't want triggered. This is achieved by generating the assignment as `(untyped this).$name = $value`. To make the code typesafe again, this is prefixed with `if (false) { var __tmp = this.$name; __tmp = $value; }`. This code is later thrown out by the compiler. Its role is to ensure type safety without interfering with the normal typing order.
+It is important to know that when you initialize a field with `options.bypass` set to true, existing setters will be bypassed. That's particularly helpful if your setter triggers a side effect that you don't want triggered. This is achieved by generating the assignment as `(untyped this).$name = $value`. To make the code typesafe again, this is prefixed with `if (false) { var __tmp = this.$name; __tmp = $value; }`. This code is later thrown out by the compiler. Its role is to ensure type safety without interfering with the normal typing order.

 Setter bypass also causes the field to gain an `@:isVar`. And currently, with `-dce full`, additional code will be generated to avoid the field to be eliminated.

--- a/bin/.gitignore
+++ b/bin/.gitignore
@@ -1 +0,0 @@
-*.n
--- a/dev.hxml
+++ b/dev.hxml
@@ -0,0 +1,6 @@
+tests.hxml
+-lib travix
+-lib tink_macro
+-lib hx3compat
+-js whatever.js
+--no-output
--- a/haxe_libraries/hx3compat.hxml
+++ b/haxe_libraries/hx3compat.hxml
@@ -0,0 +1,3 @@
+# @install: lix --silent download "haxelib:/hx3compat#1.0.3" into hx3compat/1.0.3/haxelib
+-cp ${HAXE_LIBCACHE}/hx3compat/1.0.3/haxelib/std
+-D hx3compat=1.0.3
--- a/haxe_libraries/hxnodejs.hxml
+++ b/haxe_libraries/hxnodejs.hxml
@@ -0,0 +1,6 @@
+# @install: lix --silent download "haxelib:/hxnodejs#12.0.0" into hxnodejs/12.0.0/haxelib
+-cp ${HAXE_LIBCACHE}/hxnodejs/12.0.0/haxelib/src
+-D hxnodejs=12.0.0
+--macro allowPackage('sys')
+# should behave like other target defines and not be defined in macro context
+--macro define('nodejs')
--- a/haxe_libraries/tink_chunk.hxml
+++ b/haxe_libraries/tink_chunk.hxml
@@ -0,0 +1,3 @@
+# @install: lix --silent download "gh://github.com/haxetink/tink_chunk#f095072a029f1f50ce5f2cc0a690c3e834298d96" into tink_chunk/0.3.1/github/f095072a029f1f50ce5f2cc0a690c3e834298d96
+-cp ${HAXE_LIBCACHE}/tink_chunk/0.3.1/github/f095072a029f1f50ce5f2cc0a690c3e834298d96/src
+-D tink_chunk=0.3.1
--- a/haxe_libraries/tink_cli.hxml
+++ b/haxe_libraries/tink_cli.hxml
@@ -0,0 +1,8 @@
+# @install: lix --silent download "gh://github.com/haxetink/tink_cli#1278ad2a34fd5e2403e414aefe09bb938d0c8825" into tink_cli/0.5.1/github/1278ad2a34fd5e2403e414aefe09bb938d0c8825
+-lib tink_io
+-lib tink_macro
+-lib tink_stringly
+-cp ${HAXE_LIBCACHE}/tink_cli/0.5.1/github/1278ad2a34fd5e2403e414aefe09bb938d0c8825/src
+-D tink_cli=0.5.1
+# Make sure docs are generated
+-D use-rtti-doc
--- a/haxe_libraries/tink_core.hxml
+++ b/haxe_libraries/tink_core.hxml
@@ -0,0 +1,3 @@
+# @install: lix --silent download "gh://github.com/haxetink/tink_core#abee932c4e724517090238b6527eac28874c0354" into tink_core/1.27.1/github/abee932c4e724517090238b6527eac28874c0354
+-cp ${HAXE_LIBCACHE}/tink_core/1.27.1/github/abee932c4e724517090238b6527eac28874c0354/src
+-D tink_core=1.27.1
--- a/haxe_libraries/tink_io.hxml
+++ b/haxe_libraries/tink_io.hxml
@@ -0,0 +1,5 @@
+# @install: lix --silent download "gh://github.com/haxetink/tink_io#e4a92421865adfd7037474937cffacaa1abd4338" into tink_io/0.8.0/github/e4a92421865adfd7037474937cffacaa1abd4338
+-lib tink_chunk
+-lib tink_streams
+-cp ${HAXE_LIBCACHE}/tink_io/0.8.0/github/e4a92421865adfd7037474937cffacaa1abd4338/src
+-D tink_io=0.8.0
--- a/haxe_libraries/tink_macro.hxml
+++ b/haxe_libraries/tink_macro.hxml
@@ -0,0 +1,3 @@
+-D tink_macro
+-cp src
+-lib tink_core
--- a/haxe_libraries/tink_streams.hxml
+++ b/haxe_libraries/tink_streams.hxml
@@ -0,0 +1,6 @@
+# @install: lix --silent download "gh://github.com/haxetink/tink_streams#aa006c354e742164c4f7bc8ec4532bc9154fb0d0" into tink_streams/0.3.3/github/aa006c354e742164c4f7bc8ec4532bc9154fb0d0
+-lib tink_core
+-cp ${HAXE_LIBCACHE}/tink_streams/0.3.3/github/aa006c354e742164c4f7bc8ec4532bc9154fb0d0/src
+-D tink_streams=0.3.3
+# temp for development, delete this file when pure branch merged
+-D pure
--- a/haxe_libraries/tink_stringly.hxml
+++ b/haxe_libraries/tink_stringly.hxml
@@ -0,0 +1,4 @@
+-D tink_stringly=0.2.0
+# @install: lix --silent download "haxelib:/tink_stringly#0.2.0" into tink_stringly/0.2.0/haxelib
+-lib tink_core
+-cp ${HAXE_LIBCACHE}/tink_stringly/0.2.0/haxelib/src
--- a/haxe_libraries/travix.hxml
+++ b/haxe_libraries/travix.hxml
@@ -0,0 +1,7 @@
+# @install: lix --silent download "gh://github.com/back2dos/travix#354c2b2a82cc3b03e2f87cc1b6f0ddc0a6a5c133" into travix/0.15.0/github/354c2b2a82cc3b03e2f87cc1b6f0ddc0a6a5c133
+# @post-install: cd ${HAXE_LIBCACHE}/travix/0.15.0/github/354c2b2a82cc3b03e2f87cc1b6f0ddc0a6a5c133 && haxe -cp src --run travix.PostDownload
+# @run: haxelib run-dir travix ${HAXE_LIBCACHE}/travix/0.15.0/github/354c2b2a82cc3b03e2f87cc1b6f0ddc0a6a5c133
+-lib tink_cli
+-cp ${HAXE_LIBCACHE}/travix/0.15.0/github/354c2b2a82cc3b03e2f87cc1b6f0ddc0a6a5c133/src
+-D travix=0.15.0
+--macro travix.Macro.setup()
--- a/haxelib.json
+++ b/haxelib.json
@@ -1,20 +1,20 @@
 {
 	"name": "tink_macro",
-	"license": "MIT",
+	"description": "The macro toolkit ;)",
+	"classPath": "src",
+	"dependencies": {
+		"tink_core": ""
+	},
+	"url": "https://github.com/haxetink/tink_macro",
+	"contributors": [
+		"back2dos"
+	],
+	"version": "0.24.0",
+	"releasenote": "Add eval to Expr/TypedExpr.",
 	"tags": [
 		"tink",
 		"macro",
 		"utility"
 	],
-	"classPath": "src",
-	"description": "The macro toolkit ;)",
-	"contributors": [
-		"back2dos"
-	],
-	"releasenote": "Build cache works better with compiler server.",
-	"version": "0.13.0",
-	"url": "http://haxetink.org/tink_macro",
-	"dependencies": {
-		"tink_core": ""
-	}
+	"license": "MIT"
 }
--- a/src/tink/MacroApi.hx
+++ b/src/tink/MacroApi.hx
@@ -4,9 +4,12 @@ import haxe.macro.Expr.TypeDefinition;

 using tink.CoreApi;
 using tink.macro.Positions;
+using StringTools;

 typedef Positions = tink.macro.Positions;
 typedef ExprTools = haxe.macro.ExprTools;
+typedef TypedExprTools = haxe.macro.TypedExprTools;
+typedef TypedExprs = tink.macro.TypedExprs;
 typedef Exprs = tink.macro.Exprs;
 typedef Functions = tink.macro.Functions;
 typedef Metadatas = tink.macro.Metadatas;
@@ -14,6 +17,7 @@ typedef Bouncer = tink.macro.Bouncer;
 typedef Types = tink.macro.Types;
 typedef Binops = tink.macro.Ops.Binary;
 typedef Unops = tink.macro.Ops.Unary;
+typedef TypeMap<T> = tink.macro.TypeMap<T>;

 //TODO: consider adding stuff from haxe.macro.Expr here
 typedef MacroOutcome<D, F> = tink.core.Outcome<D, F>;
@@ -26,13 +30,122 @@ typedef ClassBuilder = tink.macro.ClassBuilder;
 typedef TypeResolution = Ref<Either<String, TypeDefinition>>;

 class MacroApi {
-  
-  static var idCounter = 0;  
-  
+
+  static var MAIN_CANDIDATES = ['-main', '-x', '--run'];
+  static public function getMainClass():Option<String> {
+    var args = Sys.args();
+
+    for (c in MAIN_CANDIDATES)
+      switch args.indexOf(c) {
+        case -1:
+        case v: return Some(args[v+1]);
+      }
+
+    return None;
+  }
+
+  @:persistent static var idCounter = 0;
+
  @:noUsing static public inline function tempName(?prefix:String = 'tmp'):String
    return '__tink_' + prefix + Std.string(idCounter++);
-    
-  static public function pos() 
+
+  static public function pos()
    return haxe.macro.Context.currentPos();

-}
+  static public var completionPoint(default, null):Option<{
+    var file(default, never):String;
+    var content(default, never):Null<String>;
+    var pos(default, never):Int;
+  }>;
+
+  static public function getBuildFields():Option<Array<haxe.macro.Expr.Field>>
+    return switch completionPoint {
+      case Some(v) if (v.content != null && (v.content.charAt(v.pos - 1) == '@' || (v.content.charAt(v.pos - 1) == ':' && v.content.charAt(v.pos - 2) == '@'))): None;
+      default: Some(haxe.macro.Context.getBuildFields());
+    }
+
+  static public var args(default, null):Iterable<String>;
+  static var initialized = initArgs();
+
+  static function initArgs() {
+    var sysArgs = Sys.args();
+    args = sysArgs;
+    completionPoint = switch sysArgs.indexOf('--display') {
+      case -1: None;
+      case sysArgs[_ + 1] => arg:
+        if (arg.startsWith('{"jsonrpc":')) {
+          var payload:{
+            jsonrpc:String,
+            method:String,
+            params:{
+              file:String,
+              offset:Int,
+              contents:String,
+            }
+          } = haxe.Json.parse(arg);
+
+          switch payload {
+            case { jsonrpc: '2.0', method: 'display/completion' }:
+              Some({
+                file: payload.params.file,
+                content: payload.params.contents,
+                pos: payload.params.offset,
+              });
+            default: None;
+          }
+        }
+        else None;
+    }
+    try haxe.macro.Context.onMacroContextReused(initArgs)
+    catch (all:Dynamic) {}
+    return true;
+  }
+
+}
+
+
+#if (haxe_ver >= 4)
+  typedef ObjectField = haxe.macro.Expr.ObjectField;
+  typedef QuoteStatus = haxe.macro.Expr.QuoteStatus;
+#else
+  enum QuoteStatus {
+    Unquoted;
+    Quoted;
+  }
+  private typedef F = {
+    var field:String;
+    var expr:haxe.macro.Expr;
+  }
+
+  @:forward
+  abstract ObjectField(F) to F {
+
+    static var QUOTED = "@$__hx__";
+
+    inline function new(o) this = o;
+
+    public var field(get, never):String;
+
+    function get_field()
+      return
+        if (quotes == Quoted)
+          this.field.substr(QUOTED.length);
+        else this.field;
+
+    public var quotes(get, never):QuoteStatus;
+
+    function get_quotes()
+      return if (StringTools.startsWith(this.field, QUOTED)) Quoted else Unquoted;
+
+    @:from static function ofFull(o:{>F, quotes:QuoteStatus }):ObjectField
+      return switch o.quotes {
+        case null | Unquoted:
+          new ObjectField({ field: o.field, expr: o.expr });
+        default:
+          new ObjectField({ field: QUOTED + o.field, expr: o.expr });
+      }
+
+    @:from static function ofOld(o:F):ObjectField
+      return new ObjectField(o);
+  }
+#end
--- a/src/tink/macro/Bouncer.hx
+++ b/src/tink/macro/Bouncer.hx
@@ -3,7 +3,7 @@ package tink.macro;
 #if macro
  import haxe.macro.Context;
  import haxe.macro.Expr;
-  
+
  using tink.macro.Positions;
  using tink.macro.Exprs;
 #end
@@ -15,7 +15,7 @@ package tink.macro;
    static public function bounceExpr(e:Expr, transform:Expr->Expr) {
      var id = idCounter++,
        pos = e.pos;
-      outerMap.set(id, transform);      
+      outerMap.set(id, transform);
      return macro @:pos(e.pos) tink.macro.Bouncer.catchBounceExpr($e, $v{id});
    }
    static public function bounce(f:Void->Expr, ?pos:Position) {
@@ -29,35 +29,41 @@ package tink.macro;
        pos = e.pos;
      outerMap.set(id, transform);
      return macro @:pos(e.pos) tink.macro.Bouncer.makeOuter($e).andBounce($v{id});
-    }    
+    }
    static function doOuter(id:Int, e:Expr) {
      return
-        if (outerMap.exists(id)) 
+        if (outerMap.exists(id))
          outerMap.get(id)(e);
        else
-          Context.currentPos().error('unknown id ' + id);  
+          Context.currentPos().error('unknown id ' + id);
    }
    static function doBounce(id:Int) {
      return
-        if (bounceMap.exists(id)) 
+        if (bounceMap.exists(id))
          bounceMap.get(id)();
        else
-          Context.currentPos().error('unknown id ' + id);  
+          Context.currentPos().error('unknown id ' + id);
    }
+    static public var lastEvaled(default, null):Dynamic;
  #else
-  @:noUsing static public function makeOuter<A>(a:A):Bouncer 
+  @:noUsing static public function makeOuter<A>(a:A):Bouncer
    return null;
  #end
-  @:noUsing macro public function andBounce(ethis:Expr, id:Int) 
+  @:noUsing macro public function andBounce(ethis:Expr, id:Int)
    return
      switch (ethis.expr) {
        case ECall(_, params): doOuter(id, params[0]);
        default: ethis.reject();
      }

-  @:noUsing macro static public function catchBounce(id:Int) 
+  @:noUsing static public macro function eval(f:Void->Dynamic) {
+    lastEvaled = f();
+    return macro null;
+  }
+
+  @:noUsing macro static public function catchBounce(id:Int)
    return doBounce(id);
-  
+
  @:noUsing macro static public function catchBounceExpr(e:Expr, id:Int)
    return doOuter(id, e);
 }
--- a/src/tink/macro/BuildCache.hx
+++ b/src/tink/macro/BuildCache.hx
@@ -31,23 +31,23 @@ typedef BuildContext3 = {>BuildContext2,
  type3:Type,
 }

-class BuildCache { 
-  
-  static var cache = new Map();
-  
-  static public function getType3(name, ?types, ?pos:Position, build:BuildContext3->TypeDefinition) {
+class BuildCache {
+
+  @:persistent static var cache = new Map();
+
+  static public function getType3(name, ?types, ?pos:Position, build:BuildContext3->TypeDefinition, ?normalizer:Type->Type) {
     if (types == null)
      switch Context.getLocalType() {
        case TInst(_.toString() == name => true, [t1, t2, t3]):
          types = { t1: t1, t2: t2, t3: t3 };
        default:
          throw 'assert';
-      }  
-      
+      }
+
    var t1 = types.t1.toComplexType(),
        t2 = types.t2.toComplexType(),
        t3 = types.t2.toComplexType();
-        
+
    return getType(name, (macro : { t1: $t1, t2: $t2, t3: $t3 } ).toType(), pos, function (ctx) return build({
      type: types.t1,
      type2: types.t2,
@@ -55,81 +55,95 @@ class BuildCache {
      pos: ctx.pos,
      name: ctx.name,
      usings: ctx.usings
-    }));   
+    }), normalizer);
  }
-  
-  static public function getTypeN(name, ?types, ?pos:Position, build:BuildContextN->TypeDefinition) {
-    
+
+  static public function getTypeN(name, ?types, ?pos:Position, build:BuildContextN->TypeDefinition, ?normalizer:Type->Type) {
+
    if (pos == null)
      pos = Context.currentPos();
-    
+
    if (types == null)
      switch Context.getLocalType() {
        case TInst(_.toString() == name => true, params):
          types = params;
        default:
          throw 'assert';
-      }  
-      
+      }
+
    var compound = ComplexType.TAnonymous([for (i in 0...types.length) {
      name: 't$i',
      pos: pos,
-      kind: FVar(types[i].toComplexType()),
+      kind: FVar(switch types[i] {
+        case TInst(_.get().kind => KExpr(e), _):
+          TPath('tink.macro.ConstParam'.asTypePath([TPExpr(e)]));
+        case t: t.toComplex();
+      }),
    }]).toType();
-        
+
    return getType(name, compound, pos, function (ctx) return build({
      types: types,
      pos: ctx.pos,
      name: ctx.name,
      usings: ctx.usings
-    }));
-  }  
-  
-  static public function getType2(name, ?types, ?pos:Position, build:BuildContext2->TypeDefinition) {
+    }), normalizer);
+  }
+
+  static public function getType2(name, ?types, ?pos:Position, build:BuildContext2->TypeDefinition, ?normalizer:Type->Type) {
    if (types == null)
      switch Context.getLocalType() {
        case TInst(_.toString() == name => true, [t1, t2]):
          types = { t1: t1, t2: t2 };
        default:
          throw 'assert';
-      }  
-      
+      }
+
    var t1 = types.t1.toComplexType(),
        t2 = types.t2.toComplexType();
-        
+
    return getType(name, (macro : { t1: $t1, t2: $t2 } ).toType(), pos, function (ctx) return build({
      type: types.t1,
      type2: types.t2,
      pos: ctx.pos,
      name: ctx.name,
      usings: ctx.usings
-    }));
+    }), normalizer);
  }

-  static public function getType(name, ?type, ?pos:Position, build:BuildContext->TypeDefinition) {
-    
-    if (pos == null)
-      pos = Context.currentPos();
-    
-    if (type == null)
+  static public function getParams(name:String, ?pos:Position)
+    return
      switch Context.getLocalType() {
-        case TInst(_.toString() == name => true, [v]):
-          type = v;
-        case TInst(_.toString() == name => true, _):
-          Context.fatalError('type parameter expected', pos);
+        case TInst(_.toString() == name => true, v):
+          Success(v);
        case TInst(_.get() => { pos: pos }, _):
-          Context.fatalError('Expected $name', pos);
-        default:
-          throw 'assert';
-      }  
-      
-    var forName = 
+          pos.makeFailure('Expected $name');
+        case v:
+          pos.makeFailure('$v should be a class');
+      }
+
+  static public function getParam(name:String, ?pos:Position)
+    return
+      getParams(name, pos)
+        .flatMap(function (args:Array<Type>) return switch args {
+          case [v]: Success(v);
+          case []: pos.makeFailure('type parameter expected');
+          default: pos.makeFailure('too many parameters');
+        });
+
+  static public function getType(name, ?type, ?pos:Position, build:BuildContext->TypeDefinition, ?normalizer:Type->Type) {
+
+    if (type == null)
+      type = getParam(name, pos).sure();
+
+    var forName =
      switch cache[name] {
-        case null: cache[name] = new Group(name);
+        case null: cache[name] = new Group(name, normalizer);
        case v: v;
      }
-    
-    return forName.get(type, pos, build);  
+
+    var ret = forName.get(type, pos.sanitize(), build);
+    ret.getFields();// workaround for https://github.com/HaxeFoundation/haxe/issues/7905
+    return ret;
  }
 }

@@ -138,23 +152,24 @@ private typedef Entry = {
 }

 private class Group {
-  
+
  var name:String;
  var counter = 0;
-  var entries = new TypeMap<Entry>();
-  
-  public function new(name) {
+  var entries:TypeMap<Entry>;
+
+  public function new(name, ?normalizer) {
    this.name = name;
+    this.entries = new TypeMap(normalizer);
  }
-  
+
  public function get(type:Type, pos:Position, build:BuildContext->TypeDefinition):Type {
-    
+
    function make(path:String) {
      var usings = [];
      var def = build({
-        pos: pos, 
-        type: type, 
-        usings: usings, 
+        pos: pos,
+        type: type,
+        usings: usings,
        name: path.split('.').pop()
      });

@@ -163,15 +178,15 @@ private class Group {
      return Context.getType(path);
    }

-    function doMake() 
-      while (true) 
+    function doMake()
+      while (true)
        switch '$name${counter++}' {
          case _.definedType() => Some(_):
          case v:
            return make(v);
-        } 
+        }

-    return 
+    return
      switch entries.get(type) {
        case null:
          doMake();
--- a/src/tink/macro/ClassBuilder.hx
+++ b/src/tink/macro/ClassBuilder.hx
@@ -9,51 +9,54 @@ using tink.MacroApi;
 using Lambda;

 class ClassBuilder {
-  
+
  var memberList:Array<Member>;
  var macros:Map<String,Field>;
  var constructor:Null<Constructor>;
  public var target(default, null):ClassType;
  var superFields:Map<String,Bool>;
-  
+
  var initializeFrom:Array<Field>;
-    
-  public function new(?target, ?fields) { 
-    if (target == null) 
+
+  public function new(?target, ?fields) {
+    if (target == null)
      target = Context.getLocalClass().get();
-      
+
    if (fields == null)
-      fields = Context.getBuildFields();
-    
+      fields = switch MacroApi.getBuildFields() {
+        case None: target.pos.error('Impossible to get builds fields now. Possible cause: https://github.com/HaxeFoundation/haxe/issues/9853');
+        case Some(v): v;
+      }
+
    this.initializeFrom = fields;
    this.target = target;
  }
-  
+
  function init() {
    if (initializeFrom == null) return;
-    
+
    var fields = initializeFrom;
    initializeFrom = null;
-    
+
    this.memberList = [];
    this.macros = new Map();
-    
-    for (field in fields) 
+
+    for (field in fields)
      if (field.access.has(AMacro))
        macros.set(field.name, field)
      else if (field.name == 'new') {
        var m:Member = field;
        this.constructor = new Constructor(this, m.getFunction().sure(), m.isPublic, m.pos, field.meta);
      }
-      else 
+      else
        doAddMember(field);
-        
-    
+
+
  }
-  
+
  public function getConstructor(?fallback:Function):Constructor {
    init();
-    if (constructor == null) 
+    if (constructor == null)
      if (fallback != null)
        constructor = new Constructor(this, fallback);
      else {
@@ -63,19 +66,21 @@ class ClassBuilder {
          if (cl.constructor != null) {
            try {
              var ctor = cl.constructor.get();
-              var func = Context.getTypedExpr(ctor.expr()).getFunction().sure();
-              
+              var ctorExpr = ctor.expr();
+              if (ctorExpr == null) throw 'Super constructor has no expression';
+              var func = Context.getTypedExpr(ctorExpr).getFunction().sure();
+
              for (arg in func.args) //this is to deal with type parameter substitutions
                arg.type = null;
-                
+
              func.expr = "super".resolve().call(func.getArgIdents());
              constructor = new Constructor(this, func);
              if (ctor.isPublic)
-                constructor.publish();          
+                constructor.publish();
            }
            catch (e:Dynamic) {//fails for unknown reason
              if (e == 'assert')
-                neko.Lib.rethrow(e);
+                tink.core.Error.rethrow(e);
              constructor = new Constructor(this, null);
            }
            break;
@@ -85,15 +90,15 @@ class ClassBuilder {
        if (constructor == null)
          constructor = new Constructor(this, null);
      }
-        
+
    return constructor;
  }
-  
+
  public function hasConstructor():Bool {
    init();
    return this.constructor != null;
  }
-    
+
  public function export(?verbose):Array<Field> {
    if (initializeFrom != null) return null;
    var ret = (constructor == null || target.isInterface) ? [] : [constructor.toHaxe()];
@@ -108,24 +113,24 @@ class ClassBuilder {
    }
    for (m in macros)
      ret.push(m);
-    
-    if (verbose) 
-      for (field in ret) 
+
+    if (verbose)
+      for (field in ret)
        Context.warning(new Printer().printField(field), field.pos);
-    
-    return ret;    
+
+    return ret;
  }
  public function iterator():Iterator<Member> {
    init();
    return this.memberList.copy().iterator();
  }
-    
+
  public function hasOwnMember(name:String):Bool {
    init();
-    return 
+    return
      macros.exists(name) || memberByName(name).isSuccess();
  }
-  
+
  public function hasSuperField(name:String):Bool {
    if (superFields == null) {
      superFields = new Map();
@@ -139,55 +144,65 @@ class ClassBuilder {
    }
    return superFields.get(name);
  }
-  
+
  public function memberByName(name:String, ?pos:Position) {
    init();
    for (m in memberList)
-      if (m.name == name) 
+      if (m.name == name)
        return Success(m);
-        
+
    return pos.makeFailure('unknown member $name');
  }
-  
+
  public function removeMember(member:Member):Bool {
    init();
-    return 
+    return
      memberList.remove(member);
  }
-  
-  public function hasMember(name:String):Bool 
+
+  public function hasMember(name:String):Bool
    return hasOwnMember(name) || hasSuperField(name);

  function doAddMember(m:Member, ?front:Bool = false):Member {
    init();
-    
-    if (m.name == 'new') 
+
+    if (m.name == 'new')
      throw 'Constructor must not be registered as ordinary member';
-      
-    //if (hasOwnMember(m.name)) 
+
+    //if (hasOwnMember(m.name))
      //m.pos.error('duplicate member declaration ' + m.name);
-      
-    if (front) 
+
+    if (front)
      memberList.unshift(m);
-    else 
-      memberList.push(m);        
-      
+    else
+      memberList.push(m);
+
    return m;
-  }    
-    
+  }
+
+  public function addMembers(td:TypeDefinition):Array<Member> {
+    for (f in td.fields)
+      addMember(f);
+    return td.fields;
+  }
+
  public function addMember(m:Member, ?front:Bool = false):Member {
    doAddMember(m, front);
-    
+
    if (!m.isStatic && hasSuperField(m.name))
      m.overrides = true;
-      
+
    return m;
  }
-  
-  static public function run(plugins:Array<ClassBuilder->Void>, ?verbose) {
-    var builder = new ClassBuilder();
-    for (p in plugins)
-      p(builder);
-    return builder.export(verbose);
-  }
-}
+
+  static public function run(plugins:Array<ClassBuilder->Void>, ?verbose)
+    return switch MacroApi.getBuildFields() {
+      case None: null;
+      case Some(fields):
+        var builder = new ClassBuilder(fields);
+        for (p in plugins)
+          p(builder);
+        return builder.export(verbose);
+
+    }
+}
--- a/src/tink/macro/ConstParam.hx
+++ b/src/tink/macro/ConstParam.hx
@@ -0,0 +1,3 @@
+package tink.macro;
+
+class ConstParam<Const> {}
--- a/src/tink/macro/Constructor.hx
+++ b/src/tink/macro/Constructor.hx
@@ -1,8 +1,10 @@
 package tink.macro;

+import haxe.macro.Type;
 import haxe.macro.Expr;
 import haxe.macro.Context;
 import tink.core.Pair;
+using haxe.macro.Tools;
 using tink.MacroApi;

 enum FieldInit {
@@ -23,20 +25,20 @@ class Constructor {
  var owner:ClassBuilder;
  var meta:Metadata;
  public var isPublic:Null<Bool>;
-  
+
  public function new(owner:ClassBuilder, f:Function, ?isPublic:Null<Bool> = null, ?pos:Position, ?meta:Metadata) {
    this.nuStatements = [];
    this.owner = owner;
    this.isPublic = isPublic;
    this.pos = pos.sanitize();
-    
+
    this.onGenerateHooks = [];
    this.args = [];
    this.beforeArgs = [];
    this.afterArgs = [];
    this.meta = meta;
-    
-    this.oldStatements = 
+
+    this.oldStatements =
      if (f == null) [];
      else {
        for (i in 0...f.args.length) {
@@ -47,73 +49,145 @@ class Constructor {
          }
          beforeArgs.push(a);
        }
-          
+
        if (f.expr == null) [];
        else
          switch (f.expr.expr) {
            case EBlock(exprs): exprs;
-            default: oldStatements = [f.expr]; 
+            default: oldStatements = [f.expr];
          }
      }
-    superCall = 
+    superCall =
      if (oldStatements.length == 0) [].toBlock();
      else switch oldStatements[0] {
        case macro super($a{_}): oldStatements.shift();
        default: [].toBlock();
      }
  }
-  public function addStatement(e:Expr, ?prepend) 
+
+  public function getArgList():Array<FunctionArg>
+    return beforeArgs.concat(args).concat(afterArgs);
+
+  public function addStatement(e:Expr, ?prepend)
    if (prepend)
      this.nuStatements.unshift(e)
    else
      this.nuStatements.push(e);
-  
-  public function addArg(name:String, ?t:ComplexType, ?e:Expr, ?opt = false) 
+
+  public function addArg(name:String, ?t:ComplexType, ?e:Expr, ?opt = false)
    args.push( { name : name, opt : opt || e != null, type : t, value: e } );
-  
+
  public function init(name:String, pos:Position, with:FieldInit, ?options:{ ?prepend:Bool, ?bypass:Bool }) {
-    if (options == null) 
+    if (options == null)
      options = {};
    var e =
      switch with {
        case Arg(t, noPublish):
-          if (noPublish != true) 
+          if (noPublish != true)
            publish();
          args.push( { name : name, opt : false, type : t } );
          name.resolve(pos);
        case OptArg(e, t, noPublish):
-          if (noPublish != true) 
+          if (noPublish != true)
            publish();
          args.push( { name : name, opt : true, type : t, value: e } );
          name.resolve(pos);
        case Value(e): e;
      }
-      
-    var tmp = MacroApi.tempName();
-    
-    if (options.bypass) {
-      switch owner.memberByName(name) {
-        case Success(member): member.addMeta(':isVar');
-        default:
-      }
-      addStatement(macro @:pos(pos) (cast this).$name = if (true) $e else this.$name, options.prepend);//TODO: this seems to report type errors here rather than at the declaration position
+
+    var member = owner.memberByName(name).sure(),
+        initStatement = macro @:pos(pos) this.$name = $e;
+
+    var bypass = switch options.bypass {
+      case null:
+        switch member.kind {
+          case FProp(_, 'default' | 'null', _):
+            false;
+          #if haxe4
+          case FProp('default', 'never', _):
+            member.isFinal = true;
+            false;
+          case FProp(_, 'set', _):
+            member.addMeta(':isVar');
+            initStatement = macro @:pos(pos) @:bypassAccessor this.$name = $e;
+            false;
+          #end
+          case FProp(_):
+            true;
+          case FFun(_):
+            pos.error('cannot rebind function');
+          default: false;
+        }
+      case v: v;
    }
-    else 
-      addStatement(macro @:pos(pos) this.$name = $e, options.prepend);
+
+    if (bypass && member.kind.match(FProp(_, 'never' | 'set', _, _))) {
+
+      member.addMeta(':isVar');
+
+      addStatement((function () {
+        var fields = [for (f in  (macro this).typeof().sure().getClass().fields.get()) f.name => f];
+
+        function setDirectly(t:TypedExpr) {
+          var direct = null;
+          function seek(t:TypedExpr) {
+            switch t.expr {
+              case TField({ expr: TConst(TThis) }, FInstance(_, _, f)) if (f.get().name == name): direct = t;
+              default: t.iter(seek);
+            }
+          }
+          seek(t);
+          if (direct == null) pos.error('nope');
+          var direct = Context.storeTypedExpr(direct);
+          return macro @:pos(pos) $direct = $e;
+        }
+
+        return switch fields[name] {
+          case null:
+            pos.error('this direct initialization causes the compiler to do really weird things');
+          case f:
+            switch f.kind {
+              case FVar(_, AccNormal | AccNo):
+                macro @:pos(pos) this.$name = $e;
+              case FVar(AccNever, AccNever):
+                macro @:pos(pos) this.$name = $e;
+              case FVar(AccNo | AccNormal, AccNever):
+                setDirectly(Context.typeExpr(macro @:pos(pos) this.$name));
+              #if haxe4
+              case FVar(AccCall, _):
+                var target = Context.storeTypedExpr(Context.typeExpr(macro @:pos(pos) @:bypassAccessor this.$name));
+                macro @:pos(pos) $target = $e;
+              #else
+              case FVar(AccCall, AccNever):
+                setDirectly(fields['get_$name'].expr());
+              #end
+              case FVar(_, AccCall):
+                setDirectly(fields['set_$name'].expr());
+              default:
+                pos.error('not implemented');
+            }
+        }
+      }).bounce(), options.prepend);
+    }
+    else
+      addStatement(
+        initStatement,
+        options.prepend
+      );
  }
-  public inline function publish() 
-    if (isPublic == null) 
+  public inline function publish()
+    if (isPublic == null)
      isPublic = true;
-  
-  function toBlock() 
+
+  function toBlock()
    return [superCall]
      .concat(nuStatements)
      .concat(oldStatements)
      .toBlock(pos);
-  
-  public function onGenerate(hook) 
+
+  public function onGenerate(hook)
    this.onGenerateHooks.push(hook);
-    
+
  public function toHaxe():Field {
    var f:Function = {
      args: this.beforeArgs.concat(this.args).concat(this.afterArgs),
@@ -132,4 +206,4 @@ class Constructor {
      meta : this.meta,
    }
  }
-}
+}
--- a/src/tink/macro/Exprs.hx
+++ b/src/tink/macro/Exprs.hx
@@ -1,12 +1,11 @@
 package tink.macro;

-import Type in Inspect;
-
 import haxe.macro.Context;
 import haxe.macro.Expr;
 import haxe.macro.Type;
 import haxe.PosInfos;
 import haxe.macro.Printer;
+import haxe.DynamicAccess as Dict;

 using Lambda;
 using StringTools;
@@ -20,6 +19,7 @@ typedef VarDecl = { name : String, type : ComplexType, expr : Null<Expr> };
 typedef ParamSubst = {
  var exists(default, null):String->Bool;
  var get(default, null):String->ComplexType;
+  function iterator():Iterator<ComplexType>;
 }

 private class Heureka { public function new() {} }
@@ -34,7 +34,7 @@ class Exprs {
        case _ if (condition(e)): throw new Heureka();
        default: haxe.macro.ExprTools.iter(e, seek);
      }
-    
+
    return try {
      haxe.macro.ExprTools.iter(e, seek);
      false;
@@ -43,24 +43,33 @@ class Exprs {
  }

  static public inline function is(e:Expr, c:ComplexType)
-    return ECheckType(e, c).at(e.pos).typeof().isSuccess();
-  
-  static public function finalize(e:Expr, ?nuPos:Position, ?rules:Dynamic<String>, ?skipFields = false, ?callPos:PosInfos) {
+    return e.as(c).typeof().isSuccess();
+
+  static public inline function as(e:Expr, c:ComplexType)
+    return ECheckType(e, c).at(e.pos);
+
+  static public function eval(e:Expr):Dynamic {
+    Context.typeof(macro tink.macro.Bouncer.eval(function () return $e));
+    return Bouncer.lastEvaled;
+  }
+
+  static public function finalize(e:Expr, ?nuPos:Position, ?rules:Dict<String>, ?skipFields = false, ?callPos:PosInfos) {
    if (nuPos == null)
      nuPos = Context.currentPos();
    if (rules == null)
      rules = { };
-    function replace(s:String) 
-      return {
-        if (Reflect.hasField(rules, s)) 
-          Reflect.field(rules, s)
-        else if (s.startsWith('tmp')) {
-          Reflect.setField(rules, s, MacroApi.tempName(s.substr(3)));
-          replace(s);
-        }
-        else s;
+
+    function replace(s:String):String
+      return switch rules[s] {
+        case null:
+          if (s.startsWith('tmp')) {
+            rules[s] = MacroApi.tempName(s.substr(3));
+            replace(s);
+          }
+          else s;
+        case v: v;
      }
-      
+
    return e.transform(function (e:Expr) {
      return
        if (Context.getPosInfos(e.pos).file != callPos.fileName) e;
@@ -68,7 +77,7 @@ class Exprs {
          e.pos = nuPos;
          switch (e.expr) {
            case EVars(vars):
-              for (v in vars) 
+              for (v in vars)
                v.name = replace(v.name);
              e;
            case EField(owner, field):
@@ -83,7 +92,7 @@ class Exprs {
                for (f in fields)
                  f.field = replace(f.field);
              e;
-            default:  
+            default:
              switch (e.getIdent()) {
                case Success(s): replace(s).resolve(e.pos);
                default: e;
@@ -92,10 +101,10 @@ class Exprs {
        }
    });
  }
-  
+
  static public function withPrivateAccess(e:Expr)
-    return 
-      e.transform(function (e:Expr) 
+    return
+      e.transform(function (e:Expr)
        return
          switch (e.expr) {
            case EField(owner, field):
@@ -103,72 +112,95 @@ class Exprs {
            default: e;
          }
      );
-      
+
  static public function getPrivate(e:Expr, field:String, ?pos:Position)
    return macro @:pos(pos.sanitize()) @:privateAccess $e.$field;

-  static public function substitute(source:Expr, vars:Dynamic<Expr>, ?pos) 
-    return 
+  static public function substitute(source:Expr, vars:Dict<Expr>, ?pos)
+    return
      transform(source, function (e:Expr) {
-        return
-          switch (e.getIdent()) {
-            case Success(name):
-              if (Reflect.hasField(vars, name)) 
-                Reflect.field(vars, name);
-              else
-                e;
-            default: e;
-          }
+        return switch e {
+          case macro $i{name}:
+            switch vars[name] {
+              case null: e;
+              case v: v;
+            }
+          default: e;
+        }
      }, pos);
-  
-  static public inline function ifNull(e:Expr, fallback:Expr) 
+
+  static public inline function ifNull(e:Expr, fallback:Expr)
    return
      switch e {
        case macro null: fallback;
        default: e;
      }
-  
-  static public function substParams(source:Expr, subst:ParamSubst, ?pos):Expr 
-    return crawl(
-      source, 
-      function (e) 
-        return switch e.expr {
-          case ENew({ pack: [], name: name }, args) if (subst.exists(name)):
-            switch subst.get(name) {
-              case TPath(p):
-                ENew(p, args).at(e.pos);
-              default: e;//TODO: report an error?
-            }
-          case EConst(CIdent(name)) if (subst.exists(name)):
+
+  static public function substParams(source:Expr, subst:ParamSubst, ?pos:Position):Expr {
+    if (!subst.iterator().hasNext())
+      return source;
+
+    function replace(ct:ComplexType)
+      return switch ct {
+        case TPath({ pack: [], name: name }) if (subst.exists(name)):
+          subst.get(name);
+        default: ct;
+      }
+
+    return source
+      .transform(
+        function (e) return switch e {
+          case macro $i{name} if (subst.exists(name)):
            switch subst.get(name) {
              case TPath({ pack: pack, name: name }):
                pack.concat([name]).drill(e.pos);
              default: e;//TODO: report an error?
            }
          default: e;
-        },
-      function (c:ComplexType) 
-        return
-          switch (c) {
-            case TPath({ pack: [], name: name }) if (subst.exists(name)):
-              subst.get(name);
-            default: c;
+        })
+      .mapTypes(replace);
+  }
+
+  static public function mapTypes(e:Expr, transformer:ComplexType->ComplexType, ?pos:Position) {
+    return e.transform(
+      function (e) return switch e {
+        case { expr: ENew(p, args) }:
+          switch TPath(p).map(transformer) {
+            case TPath(nu):
+              ENew(nu, args).at(e.pos);
+            case v:
+              pos.error(v.toString() + ' cannot be instantiated in ${e.pos}');
          }
-      , pos);
-  
-  static public function transform(source:Expr, transformer:Expr->Expr, ?pos):Expr 
-    return crawl(source, transformer, function (t) return t, pos);
-  
-  static function crawlArray(a:Array<Dynamic>, transformer:Expr->Expr, retyper:ComplexType-> ComplexType, pos:Position):Array<Dynamic>
+        case macro cast($v, $ct):
+          ct = ct.map(transformer);
+          (macro @:pos(e.pos) cast($v, $ct));
+        case { expr: ECheckType(v, ct) }: // cannot use reification, because that's `EParentheses(ECheckType)` and macros can (and apparently do) generate a non-wrapped one
+          ECheckType(v, ct.map(transformer)).at(e.pos);
+        case { expr: EVars(vars) }:
+          EVars([for (v in vars) {
+            name: v.name,
+            type: v.type.map(transformer),
+            expr: v.expr,
+          }]).at(e.pos);
+        case { expr: EFunction(kind, f) }:
+          EFunction(kind, Functions.mapSignature(f, transformer)).at(e.pos);
+        default: e;
+      }
+    );
+  }
+
+  static public function transform(source:Expr, transformer:Expr->Expr, ?pos):Expr {
+    function apply(e:Expr)
+      return switch e {
+        case null | { expr: null }: e;
+        default: transformer(haxe.macro.ExprTools.map(e, apply));
+      }
+
+    return apply(source);
+  }
+
+  static public function getIterType(target:Expr)
    return
-      if (a == null) a;
-      else 
-        [for (v in a)
-          crawl(v, transformer, retyper, pos)
-        ];
-      
-  static public function getIterType(target:Expr) 
-    return 
      (macro @:pos(target.pos) {
        var t = null,
          target = $target;
@@ -176,21 +208,21 @@ class Exprs {
          t = i;
        t;
      }).typeof();
-  
+
  static public function yield(e:Expr, yielder:Expr->Expr, ?options: { ?leaveLoops: Bool }):Expr {
-    inline function rec(e) 
+    inline function rec(e)
      return yield(e, yielder, options);
-      
+
    if (options == null)
      options = { };
-      
+
    var loops = options.leaveLoops != true;
    return
      if (e == null || e.expr == null) e;
      else switch (e.expr) {
        case EVars(_):
          e.pos.error('Variable declaration not supported here');
-        case EBlock(exprs) if (exprs.length > 0): 
+        case EBlock(exprs) if (exprs.length > 0):
          exprs = exprs.copy();
          exprs.push(rec(exprs.pop()));
          EBlock(exprs).at(e.pos);
@@ -198,10 +230,11 @@ class Exprs {
          ,ETernary(econd, eif, eelse):
          EIf(econd, rec(eif), rec(eelse)).at(e.pos);
        case ESwitch(e, cases, edef):
-          cases = Reflect.copy(cases);//not exactly pretty, but does the job
-          for (c in cases)
-            c.expr = rec(c.expr);
-          ESwitch(e, cases, rec(edef)).at(e.pos);
+          ESwitch(e, [for (c in cases) {
+            expr: rec(c.expr),
+            guard: c.guard,
+            values: c.values,
+          }], rec(edef)).at(e.pos);
        case EFor(it, expr) if (loops):
          EFor(it, rec(expr)).at(e.pos);
        case EWhile(cond, body, normal) if (loops):
@@ -215,130 +248,134 @@ class Exprs {
        default: yielder(e);
      }
  }
-      
-  static function crawl(target:Dynamic, transformer:Expr->Expr, retyper:ComplexType->ComplexType, pos:Position):Dynamic
-    return
-      if (Std.is(target, Array)) 
-        crawlArray(target, transformer, retyper, pos);
-      else
-        switch (Inspect.typeof(target)) {
-          case TNull, TInt, TFloat, TBool, TFunction, TUnknown, TClass(_): target;
-          case TEnum(e): 
-            var ret:Dynamic = Inspect.createEnumIndex(e, Inspect.enumIndex(target), crawlArray(Inspect.enumParameters(target), transformer, retyper, pos));
-            if (Inspect.getEnum(ret) == ComplexType) 
-              retyper(ret);
-            else 
-              ret;              
-          case TObject:
-            var ret:Dynamic = { };
-            for (field in Reflect.fields(target))
-              Reflect.setField(ret, field, crawl(Reflect.field(target, field), transformer, retyper, pos));
-            if (Std.is(ret.expr, ExprDef)) {
-              ret = transformer(ret);
-              if (pos != null) ret.pos = pos;
-            }
-            ret;
-        }
-        
-  static public inline function iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position) 
-    return EFor(EIn(loopVar.resolve(pos), target).at(pos), body).at(pos);
-  
-  static public function toFields(object:Dynamic<Expr>, ?pos:Position)
-    return EObjectDecl([for (field in Reflect.fields(object))
-      { field:field, expr: untyped Reflect.field(object, field) }
+
+  static public inline function iterate(target:Expr, body:Expr, ?loopVar:String = 'i', ?pos:Position)
+    return macro @:pos(pos.sanitize()) for ($i{loopVar} in $target) $body;
+
+  static public function toFields(object:Dict<Expr>, ?pos:Position)
+    return EObjectDecl([for (field in object.keys())
+      { field:field, expr: object[field] }
    ]).at(pos);

  static public inline function log(e:Expr, ?pos:PosInfos):Expr {
    haxe.Log.trace(e.toString(), pos);
    return e;
  }
-  
-  static public inline function reject(e:Expr, ?reason:String = 'cannot handle expression'):Dynamic 
+
+  static public inline function reject(e:Expr, ?reason:String = 'cannot handle expression'):Dynamic
    return e.pos.error(reason);
-  
-  static public inline function toString(e:Expr):String 
+
+  static public inline function toString(e:Expr):String
    return new haxe.macro.Printer().printExpr(e);
-    
-  static public inline function at(e:ExprDef, ?pos:Position) 
+
+  static public inline function at(e:ExprDef, ?pos:Position)
    return {
      expr: e,
      pos: pos.sanitize()
    };
-  
-  static public inline function instantiate(s:String, ?args:Array<Expr>, ?params:Array<TypeParam>, ?pos:Position) 
+
+  static public inline function instantiate(s:String, ?args:Array<Expr>, ?params:Array<TypeParam>, ?pos:Position)
    return s.asTypePath(params).instantiate(args, pos);
-  
-  static public inline function assign(target:Expr, value:Expr, ?op:Binop, ?pos:Position) 
+
+  static public inline function assign(target:Expr, value:Expr, ?op:Binop, ?pos:Position)
    return binOp(target, value, op == null ? OpAssign : OpAssignOp(op), pos);
-  
-  static public inline function define(name:String, ?init:Expr, ?typ:ComplexType, ?pos:Position) 
+
+  static public inline function define(name:String, ?init:Expr, ?typ:ComplexType, ?pos:Position)
    return at(EVars([ { name:name, type: typ, expr: init } ]), pos);
-  
-  static public inline function add(e1:Expr, e2, ?pos) 
+
+  static public inline function add(e1:Expr, e2, ?pos)
    return binOp(e1, e2, OpAdd, pos);
-    
-  static public inline function unOp(e:Expr, op, ?postFix = false, ?pos) 
+
+  static public inline function unOp(e:Expr, op, ?postFix = false, ?pos)
    return EUnop(op, postFix, e).at(pos);
-  
-  static public inline function binOp(e1:Expr, e2, op, ?pos) 
+
+  static public inline function binOp(e1:Expr, e2, op, ?pos)
    return EBinop(op, e1, e2).at(pos);
-    
-  static public inline function field(e:Expr, field, ?pos) 
+
+  static public inline function field(e:Expr, field, ?pos)
    return EField(e, field).at(pos);
-    
-  static public inline function call(e:Expr, ?params, ?pos) 
+
+  static public inline function call(e:Expr, ?params, ?pos)
    return ECall(e, params == null ? [] : params).at(pos);
-    
-  static public inline function toExpr(v:Dynamic, ?pos:Position) 
+
+  static public inline function toExpr(v:Dynamic, ?pos:Position)
    return Context.makeExpr(v, pos.sanitize());
-    
-  static public inline function toArray(exprs:Iterable<Expr>, ?pos) 
+
+  static public inline function toArray(exprs:Iterable<Expr>, ?pos)
    return EArrayDecl(exprs.array()).at(pos);
-    
-  static public inline function toMBlock(exprs:Array<Expr>, ?pos) 
+
+  static public inline function toMBlock(exprs:Array<Expr>, ?pos)
    return EBlock(exprs).at(pos);
-    
-  static public inline function toBlock(exprs:Iterable<Expr>, ?pos) 
-    return toMBlock(Lambda.array(exprs), pos);    
-    
+
+  static public inline function toBlock(exprs:Iterable<Expr>, ?pos)
+    return toMBlock(Lambda.array(exprs), pos);
+
  static public function drill(parts:Array<String>, ?pos:Position, ?target:Expr) {
-    if (target == null) 
+    if (target == null)
      target = at(EConst(CIdent(parts.shift())), pos);
    for (part in parts)
      target = field(target, part, pos);
-    return target;    
+    return target;
  }
-  
-  static public inline function resolve(s:String, ?pos) 
+
+  static public inline function resolve(s:String, ?pos)
    return drill(s.split('.'), pos);
-  
+
+  static var scopes = new Array<Array<Var>>();
+
+  static function inScope<T>(a:Array<Var>, f:Void->T) {
+    scopes.push(a);
+
+    inline function leave()
+      scopes.pop();
+    try {
+      var ret = f();
+      leave();
+      return ret;
+    }
+    catch (e:Dynamic) {
+      leave();
+      return Error.rethrow(e);
+    }
+  }
+
+  static public function scoped<T>(f:Void->T)
+    return inScope([], f);
+
+  static public function inSubScope<T>(f:Void->T, a:Array<Var>)
+    return inScope(switch scopes[scopes.length - 1] {
+      case null: a;
+      case v: v.concat(a);
+    }, f);
+
  static public function typeof(expr:Expr, ?locals)
    return
      try {
-        if (locals != null) 
+        if (locals == null)
+          locals = scopes[scopes.length - 1];
+        if (locals != null)
          expr = [EVars(locals).at(expr.pos), expr].toMBlock(expr.pos);
        Success(Context.typeof(expr));
      }
-      catch (e:Error) {
-        var m:Dynamic = e.message;
-        e.pos.makeFailure(m);
+      catch (e:haxe.macro.Error) {
+        e.pos.makeFailure(e.message);
      }
      catch (e:Dynamic) {
        expr.pos.makeFailure(e);
-      }        
-    
-  static public inline function cond(cond:Expr, cons:Expr, ?alt:Expr, ?pos) 
+      }
+
+  static public inline function cond(cond:Expr, cons:Expr, ?alt:Expr, ?pos)
    return EIf(cond, cons, alt).at(pos);
-    
-  static public function isWildcard(e:Expr) 
-    return 
+
+  static public function isWildcard(e:Expr)
+    return
      switch e {
        case macro _: true;
        default: false;
      }
-      
-  static public function getString(e:Expr) 
-    return 
+
+  static public function getString(e:Expr)
+    return
      switch (e.expr) {
        case EConst(c):
          switch (c) {
@@ -346,10 +383,10 @@ class Exprs {
            default: e.pos.makeFailure(NOT_A_STRING);
          }
        default: e.pos.makeFailure(NOT_A_STRING);
-      }      
-    
-  static public function getInt(e:Expr) 
-    return 
+      }
+
+  static public function getInt(e:Expr)
+    return
      switch (e.expr) {
        case EConst(c):
          switch (c) {
@@ -357,22 +394,22 @@ class Exprs {
            default: e.pos.makeFailure(NOT_AN_INT);
          }
        default: e.pos.makeFailure(NOT_AN_INT);
-      }              
-  
-  static public function getIdent(e:Expr) 
-    return 
+      }
+
+  static public function getIdent(e:Expr)
+    return
      switch (e.expr) {
        case EConst(c):
          switch (c) {
            case CIdent(id): Success(id);
            default: e.pos.makeFailure(NOT_AN_IDENT);
          }
-        default: 
+        default:
          e.pos.makeFailure(NOT_AN_IDENT);
-      }          
-  
-  static public function getName(e:Expr) 
-    return 
+      }
+
+  static public function getName(e:Expr)
+    return
      switch (e.expr) {
        case EConst(c):
          switch (c) {
@@ -380,15 +417,15 @@ class Exprs {
            default: e.pos.makeFailure(NOT_A_NAME);
          }
        default: e.pos.makeFailure(NOT_A_NAME);
-      }          
-  
-  static public function getFunction(e:Expr) 
+      }
+
+  static public function getFunction(e:Expr)
    return
      switch (e.expr) {
        case EFunction(_, f): Success(f);
        default: e.pos.makeFailure(NOT_A_FUNCTION);
      }
-      
+
  static public function concat(e:Expr, with:Expr, ?pos) {
    if(pos == null) pos = e.pos;
    return
@@ -399,7 +436,23 @@ class Exprs {
        default: EBlock([e, with]).at(pos);
      }
  }
-  
+
+  static var FIRST = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  static var LATER = FIRST + '0123456789';
+
+  static public function shortIdent(i:Int) {
+    var ret = FIRST.charAt(i % FIRST.length);
+
+    i = Std.int(i / FIRST.length);
+
+    while (i > 0) {
+      ret += LATER.charAt(i % LATER.length);
+      i = Std.int(i / LATER.length);
+    }
+
+    return ret;
+  }
+
  static inline var NOT_AN_INT = "integer constant expected";
  static inline var NOT_AN_IDENT = "identifier expected";
  static inline var NOT_A_STRING = "string constant expected";
--- a/src/tink/macro/Functions.hx
+++ b/src/tink/macro/Functions.hx
@@ -4,10 +4,19 @@ import haxe.macro.Expr;

 using tink.macro.Exprs;

+#if haxe4
+private abstract Kind(FunctionKind) from FunctionKind to FunctionKind {
+  @:from static function ofString(s:String):Kind
+    return FNamed(s);
+}
+#else
+private typedef Kind = String;
+#end
+
 class Functions {
-  static public inline function asExpr(f:Function, ?name, ?pos) 
-    return EFunction(name, f).at(pos);
-  
+  static public inline function asExpr(f:Function, ?kind:Kind, ?pos)
+    return EFunction(kind, f).at(pos);
+
  static public inline function toArg(name:String, ?t, ?opt = false, ?value = null):FunctionArg {
    return {
      name: name,
@@ -22,8 +31,24 @@ class Functions {
      ret: ret,
      params: params == null ? [] : params,
      expr: if (makeReturn) EReturn(e).at(e.pos) else e
-    }    
+    }
  }
+
+  static public function mapSignature(f:Function, transform):Function
+    return {
+      ret: Types.map(f.ret, transform),
+      args: [for (a in f.args) {
+        name: a.name,
+        value: a.value,
+        type: Types.map(a.type, transform),
+        #if haxe4
+        meta: a.meta,
+        #end
+      }],
+      expr: f.expr,
+      params: Types.mapTypeParamDecls(f.params, transform),
+    }
+
  static public function getArgIdents(f:Function):Array<Expr> {
    var ret = [];
    for (arg in f.args)
--- a/src/tink/macro/Member.hx
+++ b/src/tink/macro/Member.hx
@@ -9,7 +9,7 @@ abstract Member(Field) from Field to Field {
      name: name,
      pos: pos,
      access: [APublic],
-      kind: FProp(noread ? 'null' : 'get_' + name, nowrite ? 'null' : ('set_' + name), t),
+      kind: FProp(noread ? 'null' : 'get', nowrite ? 'null' : 'set', t),
    }
    return ret;
  }
@@ -32,6 +32,7 @@ abstract Member(Field) from Field to Field {
  }
  
  public var name(get, set):String;
+  public var meta(get, set):Metadata;
  public var doc(get, set):Null<String>;
  public var kind(get, set):FieldType;
  public var pos(get, set):Position;
@@ -39,6 +40,22 @@ abstract Member(Field) from Field to Field {
  public var isStatic(get, set):Bool;
  public var isPublic(get, set):Null<Bool>;
  public var isBound(get, set):Null<Bool>;
+  #if haxe4
+  /**
+   * Setting this to true will erase any getters/setters.
+   */
+  public var isFinal(get, set):Bool;
+    function get_isFinal() return hasAccess(AFinal);
+    function set_isFinal(param) {
+      if (setAccess(AFinal, param)) //TODO: perhaps also do something about AInline
+        switch kind {
+          case FProp(_, _, t, e):
+            kind = FVar(t, e);
+          default:
+        }
+      return param;
+    }
+  #end
  
  public function getFunction()
    return
@@ -76,6 +93,11 @@ abstract Member(Field) from Field to Field {
      }
    return pos.makeFailure('missing @$name');
  }
+
+  public function metaNamed(name) 
+    return 
+      if (this.meta == null) [];
+      else [for (tag in this.meta) if (tag.name == name) tag];
  
  public inline function asField():Field return this;
  public function publish() 
@@ -86,6 +108,12 @@ abstract Member(Field) from Field to Field {
      this.access.push(APublic);
    }
  
+  inline function get_meta() return switch this.meta {
+    case null: this.meta = [];
+    case v: v;
+  }
+  inline function set_meta(param) return this.meta = param;
+
  inline function get_name() return this.name;
  inline function set_name(param) return this.name = param;
  
@@ -99,21 +127,10 @@ abstract Member(Field) from Field to Field {
  inline function set_pos(param) return this.pos = param;
  
  inline function get_overrides() return hasAccess(AOverride);
-  inline function set_overrides(param) {
-    changeAccess(
-      param ? AOverride : null, 
-      param ? null : AOverride
-    );
-    return param;
-  }
+  inline function set_overrides(param) return setAccess(AOverride, param);
+
  inline function get_isStatic() return hasAccess(AStatic);
-  function set_isStatic(param) {
-    changeAccess(
-      param ? AStatic : null, 
-      param ? null : AStatic
-    );
-    return param;
-  }
+  inline function set_isStatic(param) return setAccess(AStatic, param);
  
  function get_isPublic() {
    if (this.access != null)    
@@ -167,6 +184,15 @@ abstract Member(Field) from Field to Field {
        if (x == a) return true;
    return false;
  }
+
+  function setAccess(a:Access, isset:Bool) {
+    changeAccess(
+      isset ? a : null, 
+      isset ? null : a
+    );
+    return isset;
+  }
+    
  
  function changeAccess(add:Access, remove:Access) {
    var i = 0;
@@ -190,4 +216,4 @@ abstract Member(Field) from Field to Field {
    if (add != null)
      this.access.push(add);
  }
-}
+}
--- a/src/tink/macro/Metadatas.hx
+++ b/src/tink/macro/Metadatas.hx
@@ -3,6 +3,7 @@ package tink.macro;
 import haxe.macro.Expr;

 class Metadatas {  
+  static var printer = new haxe.macro.Printer();
  static public function toMap(m:Metadata) {
    var ret = new Map<String,Array<Array<Expr>>>();
    if (m != null)
@@ -18,4 +19,8 @@ class Metadatas {
    return 
      if (m == null) [];
      else [for (meta in m) if (meta.name == name) meta.params];  
+      
+  static public inline function toString(m:MetadataEntry) {
+    return printer.printMetadata(m);
+  }
 }
--- a/src/tink/macro/Positions.hx
+++ b/src/tink/macro/Positions.hx
@@ -12,7 +12,7 @@ class Positions {
    return 
      switch outcome {
        case Success(d): d;
-        case Failure(f): sanitize(pos).error(f);
+        case Failure(f): pos.error(f);
      }
  
  static public function makeBlankType(pos:Position):ComplexType 
@@ -32,7 +32,17 @@ class Positions {


  static public function error(pos:Position, error:Dynamic):Dynamic 
-    return errorFunc(sanitize(pos), Std.string(error));
+    return 
+      switch Std.instance(error, tink.core.Error) {
+        case null: errorFunc(sanitize(pos), Std.string(error));
+        case error: 
+          errorFunc(
+            error.pos, 
+            error.message + 
+              if (pos == null) ''
+              else ' (referenced from ' + Std.string(pos).substr(5)
+          );
+      }
  
  static function contextError(pos:Position, error:String):Dynamic 
    return Context.fatalError(error, pos);
--- a/src/tink/macro/Sisyphus.hx
+++ b/src/tink/macro/Sisyphus.hx
@@ -2,6 +2,8 @@ package tink.macro;

 import haxe.macro.Expr;
 import haxe.macro.Type;
+using haxe.macro.Tools;
+using tink.MacroApi;

 class Sisyphus {

@@ -17,19 +19,28 @@ class Sisyphus {
        case AccCall: getOrSet;
        case AccInline: "default";
        case AccRequire(_, _): "default";
+        default: throw "not implemented";
      }
    }
    if (cf.params.length == 0) {
      name: cf.name,
      doc: cf.doc,
-      access: cf.isPublic ? [ APublic ] : [ APrivate ],
+      access:
+        (cf.isPublic ? [ APublic ] : [ APrivate ])
+          #if haxe4 .concat(if (cf.isFinal) [AFinal] else []) #end
+        ,
      kind: switch([ cf.kind, cf.type ]) {
+        #if haxe4
+        case [ FVar(_, _), ret ] if (cf.isFinal):
+          FVar(toComplexType(ret), null);
+        #end
        case [ FVar(read, write), ret ]:
          FProp(
            varAccessToString(read, "get"),
            varAccessToString(write, "set"),
            toComplexType(ret),
-            null);
+            null
+          );
        case [ FMethod(_), TFun(args, ret) ]:
          FFun({
            args: [
@@ -52,21 +63,32 @@ class Sisyphus {
    }
  }

-  public static function toComplexType(type : Null<Type>) : Null<ComplexType> return
+  static public function toComplexType(type : Null<Type>) : Null<ComplexType> return {
+    inline function direct()
+      return Types.toComplex(type, { direct: true });
    switch (type) {
      case null:
        null;
-      case TMono(_.get() => t):
-        t == null ? Types.toComplex(type, { direct: true }) : toComplexType(t);
+      case TEnum(_.get().isPrivate => true, _): direct();
+      case TInst(_.get().isPrivate => true, _): direct();
+      case TType(_.get().isPrivate => true, _): direct();
+      case TAbstract(_.get().isPrivate => true, _): direct();
+      case TMono(_): direct();
      case TEnum(_.get() => baseType, params):
        TPath(toTypePath(baseType, params));
      case TInst(_.get() => classType, params):
        switch (classType.kind) {
          case KTypeParameter(_):
-            TPath({
-              name: classType.name,
-              pack: [],
-            });
+            var ct = Types.asComplexType(classType.name);
+            switch Types.toType(ct) {
+              case Success(TInst(_.get() => cl, _)) if (
+                cl.kind.match(KTypeParameter(_))
+                && cl.module == classType.module
+                && cl.pack.join('.') == classType.pack.join('.')
+              ): ct;
+              default:
+                direct();
+            }
          default:
            TPath(toTypePath(classType, params));
        }
@@ -74,8 +96,12 @@ class Sisyphus {
        TPath(toTypePath(baseType, params));
      case TFun(args, ret):
        TFunction(
-          [ for (a in args) a.opt ? nullable(toComplexType(a.t)) : toComplexType(a.t) ],
-          toComplexType(ret));
+          [for (a in args) {
+            var t = #if haxe4 TNamed(a.name, #else ( #end toComplexType(a.t));
+            if (a.opt) TOptional(t) else t;
+          }],
+          toComplexType(ret)
+        );
      case TAnonymous(_.get() => { fields: fields }):
        TAnonymous([ for (cf in fields) toField(cf) ]);
      case TDynamic(t):
@@ -92,14 +118,108 @@ class Sisyphus {
      default:
        throw "Invalid type";
    }
-
+  }
  static function toTypePath(baseType : BaseType, params : Array<Type>) : TypePath return {
    var module = baseType.module;
+    var name = module.substring(module.lastIndexOf(".") + 1);
+    var sub = switch baseType.name {
+      case _ == name => true: null;
+      case v: v;
+    }
+
    {
      pack: baseType.pack,
-      name: module.substring(module.lastIndexOf(".") + 1),
-      sub: baseType.name,
-      params: [ for (t in params) TPType(toComplexType(t)) ],
+      name: name,
+      sub: sub,
+      params: [for (t in params) switch t {
+        case TInst(_.get().kind => KExpr(e), _): TPExpr(e);
+        default: TPType(toComplexType(t));
+      }],
    }
  }
-}
+
+  static function exactBase<T:BaseType>(r:Ref<T>, params:Array<Type>) {
+    var t = r.get();
+    var isMain = !t.isPrivate && switch t.pack {
+      case []: t.module == t.name || t.module == 'StdTypes';
+      default: StringTools.endsWith(t.module, '.${t.name}');
+    }
+
+    return (
+      if (isMain) t.pack.concat([t.name]).join('.')
+      else t.module + '.' + t.name
+    ) + switch params {
+      case []: '';
+      case params:
+        '<${params.map(toExactString).join(', ')}>';
+    }
+  }
+
+  static inline function isFinal(c:ClassField)
+    return #if haxe4 c.isFinal #else false #end;
+
+  static function exactAnonField(c:ClassField) {
+    var kw =
+      switch c.kind {
+        case FMethod(_): 'function';
+        case FVar(_):
+          if (isFinal(c)) 'final' else 'var';
+      }
+
+    return [for (m in c.meta.get()) m.toString() + ' '].join('') + '$kw ${c.name}' + (switch c.kind {
+      case FVar(read, write):
+        (
+          if (isFinal(c) || (read == AccNormal && write == AccNormal)) ''
+          else '(${read.accessToName()}, ${read.accessToName(false)})'
+        ) + ':' + c.type.toExactString();
+      case FMethod(_):
+        switch haxe.macro.Context.follow(c.type) {
+          case TFun(arg, ret): exactSig(arg, ret, ':');
+          default: throw 'assert';
+        }
+    }) + ';';
+  }
+
+  static function exactSig(args:Array<{name:String, opt:Bool, t:Type}>, ret:Type, sep:String)
+    return '(${[for (a in args) (if (a.opt) '?' else '') + a.name + ':' + toExactString(a.t)].join(', ')})$sep${toExactString(ret)}';
+
+  static public function toExactString(t:Type)
+    return switch t {
+      case TMono(t): t.toString();
+      case TEnum(r, params): exactBase(r, params);
+      case TInst(r, params): exactBase(r, params);
+      case TType(r, params): exactBase(r, params);
+      case TAbstract(r, params): exactBase(r, params);
+      case TFun(args, ret): exactSig(args, ret, '->');
+      case TAnonymous(a): '{ ${[for (f in a.get().fields) exactAnonField(f)].join(' ')} }';
+      case TDynamic(null): 'Dynamic';
+      case TDynamic(t): 'Dynamic<${toExactString(t)}>';
+      case TLazy(f): toExactString(f());
+    }
+
+    static function eager(t:Type)
+      return switch t {
+        case TLazy(f): eager(f());
+        default: t;
+      }
+
+    static public function compare(t1:Type, t2:Type, ?follow:Bool = true) {
+      if (follow) {
+        t1 = t1.reduce();
+        t2 = t2.reduce();
+      }
+      else {
+        t1 = eager(t1);
+        t2 = eager(t2);
+      }
+
+      return switch t1.getIndex() - t2.getIndex() {
+        case 0:
+          switch Reflect.compare(t1.toString(), t2.toString()) {
+            case 0: Reflect.compare(t1.toExactString(), t2.toExactString());
+            case v: v;
+          }
+        case v: v;
+      }
+    }
+}
--- a/src/tink/macro/TypeMap.hx
+++ b/src/tink/macro/TypeMap.hx
@@ -5,29 +5,36 @@ import haxe.ds.BalancedTree;
 import haxe.macro.Context;
 import haxe.macro.Type;

-using haxe.macro.Tools;
 using tink.MacroApi;

 class TypeMap<V> extends BalancedTree<Type, V> implements IMap<Type, V> {
-  var follow:Bool;
-  
-  public function new(?noFollow:Bool) {
-    this.follow = noFollow != true;
+  var normalize:Type->Type;
+
+  public function new(?normalize:Type->Type) {
+    this.normalize = switch normalize {
+      case null: function (t) return t.reduce();
+      case fn: fn;
+    }
    super();
  }
-  
-  override function compare(k1:Type, k2:Type):Int {
-    
-    if (follow) {
-      k1 = k1.reduce();
-      k2 = k2.reduce();
+
+  override function compare(k1:Type, k2:Type):Int
+    return normalize(k1).compare(normalize(k2), false);
+
+  static public function noFollow(t:Type)
+    return t;
+
+  static public function keepNull(t:Type):Type
+    return switch t {
+      case TAbstract(_.get() => { name: 'Null', pack: [] }, [t])
+        #if !haxe4 | TType(_.get() => { name: 'Null', pack: []}, [t]) #end
+        :
+        var ct = keepNull(t).toComplex({ direct: true });
+        (macro : Null<$ct>).toType().sure();
+
+      case TLazy(f): keepNull(f());
+      case TType(_, _): keepNull(Context.follow(t, true));
+      default: t;
    }
-    
-    return switch k1.getIndex() - k2.getIndex() {
-      case 0: 
-        Reflect.compare(k1.toString(), k2.toString());//much to my surprise, this actually seems to work (at least with 3.4)
-      case v: v;
-    }
-  }
-  
+
 }
--- a/src/tink/macro/TypedExprs.hx
+++ b/src/tink/macro/TypedExprs.hx
@@ -0,0 +1,59 @@
+package tink.macro;
+
+import haxe.macro.Context;
+import haxe.macro.Type;
+import haxe.ds.Option;
+using haxe.macro.Tools;
+
+class TypedExprs {
+
+  static public function extractAll<T>(t:TypedExpr, f:TypedExpr->Option<T>):Array<T> {
+    var out = [];
+    function rec(t:TypedExpr)
+      if (t != null) {
+        switch f(t) {
+          case Some(v): out.push(v);
+          default:
+        }
+        t.iter(rec);
+      }
+    rec(t);
+    return out;
+  }
+
+  static public function extract<T>(t:TypedExpr, f:TypedExpr->Option<T>):Option<T> {
+    try extractAll(t, function (t) {
+      var ret = f(t);
+      if (ret != None)
+        throw ret;
+      return ret;
+    })
+    catch (e:Option<Dynamic>) return cast e;
+    return None;
+  }
+
+  static public function eval(t:TypedExpr)
+    return Exprs.eval(Context.storeTypedExpr(t));
+
+  static public function isThis(t:TypedExpr):Bool
+    return switch t {
+      case null: false;
+      case { expr: TConst(TThis) | TLocal({ name: '`this' })}: true;
+      default: false;
+    }
+
+  static public inline function hasThis(t)
+    return contains(t, isThis);
+
+  static public function findAll(t:TypedExpr, f:TypedExpr->Bool):Array<TypedExpr>
+    return extractAll(t, collect(f));
+
+  static public function find(t:TypedExpr, f:TypedExpr->Bool):Option<TypedExpr>
+    return extract(t, collect(f));
+
+  static public function contains(t:TypedExpr, f:TypedExpr->Bool):Bool
+    return find(t, f) != None;
+
+  static inline function collect(f)
+    return function (t) return if (f(t)) Some(t) else None;
+}
--- a/src/tink/macro/Types.hx
+++ b/src/tink/macro/Types.hx
@@ -1,186 +1,384 @@
-package tink.macro;
-
-import haxe.macro.Printer;
-import Type in Enums;
-
-import haxe.macro.Context;
-import haxe.macro.Expr;
-import haxe.macro.Type;
-
-using tink.macro.Exprs;
-using tink.macro.Positions;
-using tink.macro.Functions;
-using tink.CoreApi;
-
-class Types {
-
-  static public function definedType(typeName:String)
-    return
-      try {
-        Some(Context.getType(typeName));
-      }
-      catch (e:Dynamic) 
-        if (Std.string(e) == 'Type not found \'$typeName\'') None;
-        else neko.Lib.rethrow(e);
-  
-  static var types = new Map<Int,Void->Type>();
-  static var idCounter = 0;
-  static public function getID(t:Type, ?reduced = true)
-    return
-      if (reduced)
-        getID(reduce(t), false);
-      else
-        switch (t) {
-          case TAbstract(t, _): t.toString();
-          case TInst(t, _): t.toString();
-          case TEnum(t, _): t.toString();
-          case TType(t, _): t.toString();
-          default: null;
-        }
-
-  static public function accessToName(v:VarAccess, ?read = true)
-    return
-      switch (v) {
-        case AccNormal, AccInline: 'default';
-        case AccNo: 'null';
-        case AccNever: 'never';
-        case AccCall: if (read) 'get' else 'set';
-        default:
-          throw 'not implemented';
-      }
-
-  static function getDeclaredFields(t:ClassType, out:Array<ClassField>, marker:Map<String,Bool>) {
-    for (field in t.fields.get())
-      if (!marker.exists(field.name)) {
-        marker.set(field.name, true);
-        out.push(field);
-      }
-    if (t.isInterface)
-      for (t in t.interfaces)
-        getDeclaredFields(t.t.get(), out, marker);
-    else if (t.superClass != null)
-      getDeclaredFields(t.superClass.t.get(), out, marker);
-  }
-
-  static var fieldsCache = new Map();
-  static public function getFields(t:Type, ?substituteParams = true)
-    return
-      switch (reduce(t)) {
-        case TInst(c, params):
-          var id = c.toString(),
-              c = c.get();
-          if (!fieldsCache.exists(id)) {
-            var fields = [];
-            getDeclaredFields(c, fields, new Map());
-            fieldsCache.set(id, Success(fields));
-          }
-          var ret = fieldsCache.get(id);
-          if (substituteParams && ret.isSuccess()) {
-            var fields = Reflect.copy(ret.sure());
-
-            for (field in fields)
-              field.type = haxe.macro.TypeTools.applyTypeParameters(field.type, c.params, params);
-          }
-          fieldsCache.remove(id);//TODO: find a proper solution to avoid stale cache
-          ret;
-        case TAnonymous(anon): Success(anon.get().fields);
-        default: Context.currentPos().makeFailure('type has no fields');
-      }
-
-  static public function getStatics(t:Type)
-    return
-      switch (reduce(t)) {
-        case TInst(t, _): Success(t.get().statics.get());
-        default: Failure('type has no statics');
-      }
-
-  static public function toString(t:ComplexType)
-    return new Printer().printComplexType(t);
-
-  static public function isSubTypeOf(t:Type, of:Type, ?pos)
-    return
-      ECheckType(ECheckType(macro null, toComplex(t)).at(pos), toComplex(of)).at(pos).typeof();
-
-  static public function isDynamic(t:Type)
-    return switch reduce(t) {
-      case TDynamic(_): true;
-      default: false;
-    }
-
-  static public function toType(t:ComplexType, ?pos:Position)
-    return (macro @:pos(pos.sanitize()) {
-      var v:$t = null;
-      v;
-    }).typeof();
-
-  static public inline function instantiate(t:TypePath, ?args, ?pos)
-    return ENew(t, args == null ? [] : args).at(pos);
-
-  static public function asTypePath(s:String, ?params):TypePath {
-    var parts = s.split('.');
-    var name = parts.pop(),
-      sub = null;
-    if (parts.length > 0 && parts[parts.length - 1].charCodeAt(0) < 0x5B) {
-      sub = name;
-      name = parts.pop();
-      if(sub == name) sub = null;
-    }
-    return {
-      name: name,
-      pack: parts,
-      params: params == null ? [] : params,
-      sub: sub
-    };
-  }
-
-  static public inline function asComplexType(s:String, ?params)
-    return TPath(asTypePath(s, params));
-
-  static public inline function reduce(type:Type, ?once)
-    return Context.follow(type, once);
-
-  static public function isVar(field:ClassField)
-    return switch (field.kind) {
-      case FVar(_, _): true;
-      default: false;
-    }
-
-  static public function register(type:Void->Type):Int {
-    types.set(idCounter, type);
-    return idCounter++;
-  }
-
-  static function paramsToComplex(params:Array<Type>):Array<TypeParam>
-    return [for (p in params) TPType(toComplex(p))];
-
-  static function baseToComplex(t:BaseType, params:Array<Type>)
-    return asComplexType(t.module + '.' + t.name, paramsToComplex(params));
-
-  static public function toComplex(type:Type, ?options:{ ?direct: Bool }):ComplexType {
-    var ret =
-      if (options == null || options.direct != true) tink.macro.Sisyphus.toComplexType(type);
-      else null;
-    if (ret == null)
-      ret = lazyComplex(function () return type);
-    return ret;
-  }
-
-  static public function lazyComplex(f:Void->Type)
-    return
-      TPath({
-        pack : ['tink','macro'],
-        name : 'DirectType',
-        params : [TPExpr(register(f).toExpr())],
-        sub : null,
-      });
-      
-  static function resolveDirectType()
-    return 
-      switch reduce(Context.getLocalType()) {
-        case TInst(_, [TInst(_.get() => { kind: KExpr(e) }, _)]):  
-          types[e.getInt().sure()]();//When using compiler server, this call throws on occasion, in which case modifying this file (to update mtime and invalidate the cache) will solve the problem
-        default: 
-          throw 'assert';
-      }
-  
-}
+package tink.macro;
+
+import haxe.macro.Printer;
+
+import haxe.macro.Context;
+import haxe.macro.Expr;
+import haxe.macro.Type;
+
+using haxe.macro.Tools;
+using tink.MacroApi;
+using tink.CoreApi;
+
+import haxe.macro.Type.Ref;
+
+class Types {
+
+  static public function definedType(typeName:String)
+    return
+      try {
+        Some(Context.getType(typeName));
+      }
+      catch (e:Dynamic)
+        if (Std.string(e) == 'Type not found \'$typeName\'') None;
+        else tink.core.Error.rethrow(e);
+
+  static var types = new Map<Int,Void->Type>();
+  static var idCounter = 0;
+  static public function getID(t:Type, ?reduced = true)
+    return
+      if (reduced)
+        getID(reduce(t), false);
+      else
+        switch (t) {
+          case TAbstract(t, _): t.toString();
+          case TInst(t, _): t.toString();
+          case TEnum(t, _): t.toString();
+          case TType(t, _): t.toString();
+          default: null;
+        }
+
+  static public function accessToName(v:VarAccess, ?read = true)
+    return
+      switch (v) {
+        case AccNormal: 'default';
+        case AccInline: if (read) 'default' else 'never';
+        case AccNo: 'null';
+        case AccNever #if haxe4 | AccCtor #end: 'never';
+        case AccCall: if (read) 'get' else 'set';
+        default:
+          throw 'not implemented';
+      }
+
+  static public function getMeta(type:Type)
+    return switch type {
+      case TInst(_.get().meta => m, _): [m];
+      case TEnum(_.get().meta => m, _): [m];
+      case TAbstract(_.get().meta => m, _): [m];
+      case TType(_.get() => t, _): [t.meta].concat(getMeta(t.type));
+      case TLazy(f): getMeta(f());
+      default: [];
+    }
+
+  static function getDeclaredFields(t:ClassType, out:Array<ClassField>, marker:Map<String,Bool>) {
+    for (field in t.fields.get())
+      if (!marker.exists(field.name)) {
+        marker.set(field.name, true);
+        out.push(field);
+      }
+    if (t.isInterface)
+      for (t in t.interfaces)
+        getDeclaredFields(t.t.get(), out, marker);
+    else if (t.superClass != null)
+      getDeclaredFields(t.superClass.t.get(), out, marker);
+  }
+
+  static public function mapTypeParams(a:Array<TypeParam>, f)
+    return
+      if (a == null) null;
+      else [for (p in a) switch p {
+        case TPType(t): TPType(t.map(f));
+        default: p;
+      }];
+
+  static public function mapTypeParamDecls(a:Array<TypeParamDecl>, f:ComplexType->ComplexType):Array<TypeParamDecl>
+    return
+      if (a == null) null;
+      else [for (p in a) {
+        name: p.name,
+        meta: p.meta,
+        params: mapTypeParamDecls(p.params, f),
+        constraints: switch p.constraints {
+          case null: null;
+          case a: [for (t in a) map(t, f)];
+        }
+      }];
+
+  static public function mapTypePath(p:TypePath, transform):TypePath
+    return {
+      name: p.name,
+      pack: p.pack,
+      sub: p.sub,
+      params: mapTypeParams(p.params, transform),
+    }
+
+  static public function map(ct:ComplexType, transform:ComplexType->ComplexType) {
+    if (ct == null)
+      return null;
+    inline function rec(ct)
+      return map(transform(ct), transform);
+
+    function mapFields(fields:Array<Field>):Array<Field>
+      return [for (f in fields) {
+        name: f.name,
+        pos: f.pos,
+        kind: switch f.kind {
+          case FVar(t, e): FVar(rec(t), e);
+          case FProp(get, set, t, e): FProp(get, set, rec(t), e);
+          case FFun(f): FFun(Functions.mapSignature(f, transform));
+        },
+        access: f.access,
+        meta: switch f.meta {
+          case null: null;
+          case a: [for (m in a) {
+            name: m.name,
+            pos: m.pos,
+            params: [for (e in m.params) e.mapTypes(transform)],
+          }];
+        },
+        doc: f.doc,
+      }];
+    return transform(switch ct {
+      case TParent(t): TParent(rec(t));
+      #if haxe4
+      case TNamed(n, t): TNamed(n, rec(t));
+      case TIntersection(tl): TIntersection([for (t in tl) rec(t)]);
+      #end
+      case TOptional(t): TOptional(rec(t));
+      case TAnonymous(fields):
+        TAnonymous(mapFields(fields));
+      case TPath(p):
+        TPath(mapTypePath(p, transform));
+      case TExtend(paths, fields):
+        TExtend([for (p in paths) mapTypePath(p, transform)], mapFields(fields));
+      case TFunction(args, ret):
+        TFunction([for (a in args) rec(a)], rec(ret));
+    });
+  }
+
+  static var fieldsCache = new Map();
+  static public function getFields(t:Type, ?substituteParams = true)
+    return
+      switch (reduce(t)) {
+        case TInst(c, params):
+          var id = c.toString(),
+              c = c.get();
+          if (!fieldsCache.exists(id)) {
+            var fields = [];
+            getDeclaredFields(c, fields, new Map());
+            fieldsCache.set(id, Success(fields));
+          }
+          var ret = fieldsCache.get(id);
+          if (substituteParams && ret.isSuccess()) {
+            ret = Success([
+              for (field in ret.sure()) ({
+                name: field.name,
+                type: haxe.macro.TypeTools.applyTypeParameters(field.type, c.params, params),
+                pos: field.pos,
+                meta: field.meta,
+                doc: field.doc,
+                expr: function () return field.expr(),
+                isPublic: field.isPublic,
+                params: field.params,
+                kind: field.kind,
+                overloads: field.overloads,
+                #if haxe4
+                isExtern: field.isExtern,
+                isFinal: field.isFinal,
+                #if (haxe >= version("4.2.0-rc.1"))
+                isAbstract: field.isAbstract,
+                #end
+                #end
+              }:ClassField)
+            ]);
+          }
+          #if !haxe4
+          fieldsCache.remove(id);//TODO: find a proper solution to avoid stale cache
+          #end
+          ret;
+        case TAnonymous(anon): Success(anon.get().fields);
+        default: Context.currentPos().makeFailure('type $t has no fields');
+      }
+
+  static public function getStatics(t:Type)
+    return
+      switch (reduce(t)) {
+        case TInst(t, _): Success(t.get().statics.get());
+        default: Failure('type has no statics');
+      }
+
+
+  static public function getPosition(t:Type)
+    return
+      switch t {
+        case TInst(_.get() => {pos: pos}, _)
+        | TAbstract(_.get() => {pos: pos}, _)
+        | TType(_.get() => {pos: pos}, _)
+        | TEnum(_.get() => {pos: pos}, _) : Success(pos);
+        case TMono(_.get() => t) if (t != null): getPosition(t);
+        case TLazy(f): getPosition(f());
+        case TDynamic(v) if(v != null): getPosition(v);
+        default: Failure('type "$t" has no position');
+      }
+
+  static public function deduceCommonType(types:Array<Type>):Outcome<Type, Error> {
+    var exprs = types.map(function(t) {
+      var ct = t.toComplex();
+      return macro (null:$ct);
+    });
+
+    return switch (macro $a{exprs}).typeof() {
+      case Success(TInst(_, [v])): Success(v);
+      case Success(_): throw 'unreachable';
+      case Failure(e): Failure(new Error('Unable to deduce common type among $types'));
+    }
+  }
+
+  /// like haxe.macro.TypeTools.toString, but not lossy
+  static public function toExactString(t:Type)
+    return Sisyphus.toExactString(t);
+
+  static public function toString(t:ComplexType)
+    return new Printer().printComplexType(t);
+
+  static public function unifiesWith(from:Type, to:Type)
+    return Context.unify(from, to);
+
+  static public function isSubTypeOf(t:Type, of:Type, ?pos)
+    return
+      if (Context.unify(t, of)) ECheckType(ECheckType(macro null, toComplex(t)).at(pos), toComplex(of)).at(pos).typeof();
+      else Failure(new Error(t.toString() + ' should be ' + of.toString(), pos.sanitize()));
+
+  static public function isDynamic(t:Type)
+    return switch reduce(t) {
+      case TDynamic(_): true;
+      default: false;
+    }
+
+  static public function toType(t:ComplexType, ?pos:Position)
+    return (macro @:pos(pos.sanitize()) {
+      var v:$t = null;
+      v;
+    }).typeof();
+
+  static public inline function instantiate(t:TypePath, ?args, ?pos)
+    return ENew(t, args == null ? [] : args).at(pos);
+
+  static public function asTypePath(s:String, ?params):TypePath {
+    var parts = s.split('.');
+    var name = parts.pop(),
+      sub = null;
+    if (parts.length > 0 && parts[parts.length - 1].charCodeAt(0) < 0x5B) {
+      sub = name;
+      name = parts.pop();
+      if(sub == name) sub = null;
+    }
+    return {
+      name: name,
+      pack: parts,
+      params: params == null ? [] : params,
+      sub: sub
+    };
+  }
+
+  static public inline function asComplexType(s:String, ?params)
+    return TPath(asTypePath(s, params));
+
+  static public function reduce(type:Type, ?once) {
+    function rec(t:Type)
+      return if (once) t else reduce(t, false);
+    return switch type {
+      case TAbstract(_.get() => { name: 'Null', pack: [] }, [t]): rec(t);
+      case TLazy(_) | TType(_): rec(Context.follow(type, once));
+      default: type;
+    }
+  }
+
+  static public function isVar(field:ClassField)
+    return switch (field.kind) {
+      case FVar(_, _): true;
+      default: false;
+    }
+
+  static public function register(type:Void->Type):Int {
+    types.set(idCounter, type);
+    return idCounter++;
+  }
+
+  static function paramsToComplex(params:Array<Type>):Array<TypeParam>
+    return [for (p in params) TPType(toComplex(p))];
+
+  static function baseToComplex(t:BaseType, params:Array<Type>)
+    return asComplexType(t.module + '.' + t.name, paramsToComplex(params));
+
+  static public function toComplex(type:Type, ?options:{ ?direct: Bool }):ComplexType {
+    var ret =
+      if (options == null || options.direct != true) tink.macro.Sisyphus.toComplexType(type);
+      else null;
+    if (ret == null)
+      ret = lazyComplex(function () return type);
+    return ret;
+  }
+
+  static public function intersect(types:Array<ComplexType>, ?pos:Position):Outcome<ComplexType, Error> {
+
+    if (types.length == 1) return Success(types[1]);
+
+    #if haxe4
+    return Success(TIntersection(types));
+    #end
+    var paths = [],
+        fields = [];
+
+    for (t in types)
+      switch t {
+        case TPath(p): paths.push(p);
+        case TAnonymous(f):
+
+          for (f in f) fields.push(f);
+
+        case TExtend(p, f):
+
+          for (f in f) fields.push(f);
+          for (p in p) paths.push(p);
+
+        default:
+
+          return Failure(new Error(t.toString() + ' cannot be interesected', pos));
+      }
+
+    return Success(TExtend(paths, fields));
+  }
+
+  static public function lazyComplex(f:Void->Type)
+    return
+      TPath({
+        pack : ['tink','macro'],
+        name : 'DirectType',
+        params : [TPExpr(register(f).toExpr())],
+        sub : null,
+      });
+
+  static function resolveDirectType()
+    return
+      switch reduce(Context.getLocalType()) {
+        case TInst(_, [TInst(_.get() => { kind: KExpr(e) }, _)]):
+          types[e.getInt().sure()]();//When using compiler server, this call throws on occasion, in which case modifying this file (to update mtime and invalidate the cache) will solve the problem
+        default:
+          throw 'assert';
+      }
+
+  static public function compare(t1:Type, t2:Type, ?follow:Bool = true)
+    return Sisyphus.compare(t1, t2, follow);
+
+  static var SUGGESTIONS = ~/ \(Suggestions?: .*\)$/;
+
+  static public function getFieldSuggestions(type:ComplexType, name:String):String
+    return switch (macro (null : $type).$name).typeof() {
+      case Failure(SUGGESTIONS.match(_.message) => true): SUGGESTIONS.matched(0);
+      default: '';
+    }
+
+  static public function toDecl(p:TypeParameter):TypeParamDecl
+    return {
+      name: p.name,
+      constraints: switch p.t {
+        case TInst(_.get() => { kind: KTypeParameter(c)}, _): [for(c in c) c.toComplex()];
+        case _: throw 'unreachable';
+      }
+    }
+
+  static public function toTypeParam(p:TypeParameter):TypeParam
+    return TPType(p.t.toComplex());
+
+}
--- a/tests.hxml
+++ b/tests.hxml
@@ -1,2 +1,3 @@
 -cp tests
+-lib hx3compat
 -main Run
--- a/tests/Dummy.hx
+++ b/tests/Dummy.hx
@@ -0,0 +1,8 @@
+class Dummy {
+  public function new() {}
+  static public var p(default, never) = new Private();
+}
+
+private class Private {
+  public function new() {}
+}
--- a/tests/ExactStrings.hx
+++ b/tests/ExactStrings.hx
@@ -0,0 +1,21 @@
+import haxe.macro.Context.typeof;
+using tink.MacroApi;
+
+class ExactStrings extends Base {
+  function test() {
+    function expect(s:String, e, ?pos)
+      assertEquals(s, typeof(e).toExactString(), pos);
+
+    expect('Dummy', macro new Dummy());
+    expect('nested.Dummy', macro new nested.Dummy());
+    expect('Dummy.Private', macro Dummy.p);
+    expect('nested.Dummy.Private', macro nested.Dummy.p);
+    expect('{ @foo var x:Int; }', macro (null:{@foo var x:Int;}));
+    expect('{ @foo @bar var x:Int; }', macro (null:{@foo @bar var x:Int;}));
+    expect('{ @bar @foo var x:Int; }', macro (null:{@bar @foo var x:Int;}));// not 100% sure this is always the best choice, but let's roll with it
+    expect('{ @bar var x:Int; }', macro (null:{@bar var x:Int;}));
+    expect('{ var x:Int; var y:Int; }', macro (null:{x:Int,y:Int}));
+    expect('{ var x:Int; var y:Int; }', macro (null:{y:Int,x:Int}));
+    expect('{ function foo(x:Int, ?y:Int):Void; }', macro (null:{ function foo(x:Int, ?y:Int):Void; }));
+  }
+}
--- a/tests/Exprs.hx
+++ b/tests/Exprs.hx
@@ -1,5 +1,6 @@
 package ;

+import haxe.macro.Context;
 import haxe.macro.Expr;
 using tink.MacroApi;

@@ -7,38 +8,54 @@ class Exprs extends Base {
  function exprEq(e1:Expr, e2:Expr) {
    assertEquals(e1.toString(), e2.toString());
  }
+
+  function testShort() {
+    for (i in 0...100) {
+      var id = (100 * i).shortIdent();
+      Context.parseInlineString(id, (macro null).pos);
+      assertTrue(id.length <= 3);
+    }
+  }
+
+  function testEval() {
+    var expr = macro (untyped {foo:[{bar:234},'bar']});
+    var str = Std.string(untyped {foo:[{bar:234},'bar']});
+    assertEquals(Std.string(expr.eval()), Std.string(untyped {foo:[{bar:234},'bar']}));
+    assertEquals(Std.string(Context.typeExpr(expr).eval()), Std.string(untyped {foo:[{bar:234},'bar']}));
+
+  }
  function testGet() {
    assertEquals('foo', (macro foo).getIdent().sure());
    assertEquals('foo', (macro "foo").getString().sure());
    assertEquals('foo', (macro foo).getName().sure());
    assertEquals('foo', (macro "foo").getName().sure());
    assertEquals(5, (macro 5).getInt().sure());
-    
+
    exprEq(macro [a, b, c], (macro function (a, b, c) [a, b, c]).getFunction().sure().expr);
    assertEquals('a,b,c', [for (arg in (macro function (a, b, c) [a, b, c]).getFunction().sure().args) arg.name].join(','));
-    
+
    assertFalse((macro 'foo').getIdent().isSuccess());
    assertFalse((macro foo).getString().isSuccess());
    assertFalse((macro 5).getName().isSuccess());
    assertFalse((macro 5.1).getInt().isSuccess());
    assertFalse((macro foo).getFunction().isSuccess());
  }
-  
+
  function testShortcuts() {
    assertTrue(true);
  }
-  
+
  function testIterType() {
    assertEquals('Int', (macro [1, 2]).getIterType().sure().getID());
    assertEquals('Int', (macro [1, 2].iterator()).getIterType().sure().getID());
    assertEquals('Int', ECheckType(macro null, macro: Arrayish).at().getIterType().sure().getID());
  }
-  
+
  function testYield() {
    function yielder(e) return macro @yield $e;
    function test(x:Expr, e:Expr, ?options)
      exprEq(x, e.yield(yielder, options));
-      
+
    test(macro @yield foo, macro foo);
    test(macro @yield (foo), macro (foo));
    test(macro for (_) @yield foo, macro for (_) foo);
@@ -48,10 +65,10 @@ class Exprs extends Base {
  }
  function testSubstitute() {
    exprEq(
-      macro foo.call(arg1, arg2), 
+      macro foo.call(arg1, arg2),
      (macro bar.call(x, y)).substitute({ x: macro arg1, y: macro arg2, bar: macro foo })
    );
-    
+
    exprEq(
      macro {
        var x:Map<Int, String> = new Map(),
@@ -80,7 +97,7 @@ class Exprs extends Base {
      ])
    );
  }
-  
+
  function testConcat() {
    exprEq(macro {a; b;}, (macro a).concat(macro b));
    exprEq(macro {a; b; c;}, (macro {a; b;}).concat(macro c));
--- a/tests/Functions.hx
+++ b/tests/Functions.hx
@@ -0,0 +1,11 @@
+import haxe.macro.Context;
+import haxe.macro.Expr;
+using tink.MacroApi;
+
+class Functions extends Base {
+  function test() {
+    var f:Function = (macro function () {}).getFunction().sure();
+    f.asExpr('foo');
+    assertTrue(true);
+  }
+}
--- a/tests/Misc.hx
+++ b/tests/Misc.hx
@@ -0,0 +1,10 @@
+import tink.MacroApi;
+import haxe.unit.TestCase;
+
+using tink.CoreApi;
+
+class Misc extends TestCase {
+  function testMain() {
+    assertEquals('Run', MacroApi.getMainClass().force());
+  }
+}
--- a/tests/MyString.hx
+++ b/tests/MyString.hx
@@ -0,0 +1 @@
+typedef MyString = String;
--- a/tests/Run.hx
+++ b/tests/Run.hx
@@ -1,10 +1,13 @@
 package ;

 import haxe.unit.*;
+#if macro
+using haxe.macro.Tools;
+#end

 class Run {
-  #if !macro 
-  static function main() 
+  #if !macro
+  static function main()
    test();//It compiles ...
  #else
  static var cases:Array<TestCase> = [
@@ -12,17 +15,21 @@ class Run {
    new Types(),
    new Positions(),
    new TypeMapTest(),
+    new Functions(),
+    new Misc(),
+    new ExactStrings(),
  ];
  #end
  macro static function test() {
    var runner = new TestRunner();
    tink.macro.ClassBuilder;
+    tink.macro.BuildCache;
    for (c in cases)
      runner.add(c);
    runner.run();
    if (!runner.result.success)
      haxe.macro.Context.error(runner.result.toString(), haxe.macro.Context.currentPos());
-    
+
    return macro {
      trace('Let\'s ship it!');
    }
--- a/tests/TypeMapTest.hx
+++ b/tests/TypeMapTest.hx
@@ -1,17 +1,19 @@
 package;

 import haxe.unit.TestCase;
+import haxe.macro.Expr;

-import tink.macro.TypeMap;
-using haxe.macro.Context;
+using tink.MacroApi;

 class TypeMapTest extends TestCase {

  function testMap() {
    var t = new TypeMap();
-    var t1 = (macro [{ foo: [{ bar: '5' }]}]).typeof();
-    var t2 = (macro [{ foo: [{ bar: 5 }]}]).typeof();
-    
+    var t1 = (macro [{ foo: [{ bar: '5' }]}]).typeof().sure();
+    var t2 = (macro [{ foo: [{ bar: 5 }]}]).typeof().sure();
+    var t3 = (macro [{ foo: [{ bar: 5 }]}]).typeof().sure();
+    var t4 = (macro [{ foo: [({ bar: 5 }:{ @foo var bar:Int; })]}]).typeof().sure();
+
    t.set(t1, 0);
    assertEquals(Lambda.count(t), 1);
    t.set(t2, 1);
@@ -19,12 +21,33 @@ class TypeMapTest extends TestCase {
    t.set(t1, 2);
    assertEquals(Lambda.count(t), 2);
    t.set(t2, 3);
+    t.set(t3, 3);
    assertEquals(Lambda.count(t), 2);
-    
+    t.set(t4, 4);
+    assertEquals(Lambda.count(t), 3);
+
    assertEquals(t.get(t1), 2);
    assertEquals(t.get(t2), 3);
-    
+
    assertTrue(true);
  }
-  
+
+  function testNormalization() {
+    for (settings in [
+      { count: 4, map: new TypeMap(TypeMap.noFollow)},
+      { count: 2, map: new TypeMap(TypeMap.keepNull)},
+      { count: 1, map: new TypeMap()},
+    ]) {
+
+      function set(ct:ComplexType)
+        settings.map.set(ct.toType().sure(), ct);
+
+      set(macro : String);
+      set(macro : MyString);
+      set(macro : Null<String>);
+      set(macro : Null<MyString>);
+
+      assertEquals(settings.count, Lambda.count(settings.map));
+    }
+  }
 }
--- a/tests/Types.hx
+++ b/tests/Types.hx
@@ -1,5 +1,6 @@
 package ;

+#if macro
 import haxe.macro.Expr;
 import haxe.macro.Context;

@@ -9,39 +10,74 @@ using tink.MacroApi;
 class Types extends Base {
  function type(c:ComplexType)
    return c.toType().sure();
-    
+
  function resolve(type:String)
    return Context.getType(type);
-    
+
  inline function assertSuccess<S, F>(o:Outcome<S, F>)
    assertTrue(o.isSuccess());
-    
+
  inline function assertFailure<S, F>(o:Outcome<S, F>)
    assertFalse(o.isSuccess());
-    
+
  function testIs() {
    assertSuccess(resolve('Int').isSubTypeOf(resolve('Float')));
    assertFailure(resolve('Float').isSubTypeOf(resolve('Int')));
-  }  
-  
+  }
+
  function testFields() {
    var expected = type(macro : Void -> Iterator<Arrayish>),
      iterator = type(macro : haxe.ds.StringMap<Arrayish>).getFields(true).sure().filter(function (c) return c.name == 'iterator')[0];
-    
+
    assertSuccess(iterator.type.isSubTypeOf(expected));
    assertSuccess(expected.isSubTypeOf(iterator.type));
  }
-  
+
  function testConvert() {
    assertSuccess((macro : Int).toType());
    assertFailure((macro : Tni).toType());
    function blank()
      return type(MacroApi.pos().makeBlankType());
-    
+
    var bool = type(macro : Bool);
    assertTrue(blank().isSubTypeOf(bool).isSuccess());
    assertTrue(bool.isSubTypeOf(blank()).isSuccess());
-    
-    MacroApi.pos().makeBlankType().toString();
  }
-}
+
+  #if haxe4
+  function testFinal() {
+    var t = macro : {
+      final foo:Int;
+    };
+    switch t.toType().sure() {
+      case TAnonymous(_.get().fields => [f]): assertTrue(f.isFinal);
+      default:
+    }
+  }
+  #end
+
+  function testExpr() {
+    assertEquals('VarChar<255>', (macro : VarChar<255>).toType().sure().toComplex().toString());
+  }
+
+  function testToComplex() {
+    assertEquals('String', Context.getType('String').toComplex().toString());
+    assertEquals('tink.CoreApi.Noise', Context.getType('tink.CoreApi.Noise').toComplex().toString());
+  }
+
+  function testDeduceCommonType() {
+    function ct2t(ct:ComplexType) return ct.toType().sure();
+    assertEquals('StdTypes.Float', tink.macro.Types.deduceCommonType([(macro:Float), (macro:Int)].map(ct2t)).sure().toComplex().toString());
+    assertEquals('Types.CommonI1', tink.macro.Types.deduceCommonType([(macro:Types.CommonA), (macro:Types.CommonB), (macro:Types.CommonC)].map(ct2t)).sure().toComplex().toString());
+    assertEquals('Types.CommonI2', tink.macro.Types.deduceCommonType([(macro:Types.CommonB), (macro:Types.CommonC)].map(ct2t)).sure().toComplex().toString());
+    // assertEquals('Types.CommonI3', tink.macro.Types.deduceCommonType([(macro:Types.CommonC)].map(ct2t)).sure().toComplex().toString());
+  }
+}
+#end
+
+interface CommonI1 {}
+interface CommonI2 {}
+interface CommonI3 {}
+class CommonA implements CommonI1 {}
+class CommonB implements CommonI2 implements CommonI1 {}
+class CommonC implements CommonI3 implements CommonI2 implements CommonI1 {}
--- a/tests/VarChar.hx
+++ b/tests/VarChar.hx
@@ -0,0 +1 @@
+typedef VarChar<Const> = String;
--- a/tests/nested/Dummy.hx
+++ b/tests/nested/Dummy.hx
@@ -0,0 +1,10 @@
+package nested;
+
+class Dummy {
+  public function new() {}
+  static public var p(default, never) = new Private();
+}
+
+private class Private {
+  public function new() {}
+}
Author	SHA1	Message	Date
Juraj Kirchheim	0947d1b916	Release 0.24.0	2021-06-02 10:23:41 +02:00
Juraj Kirchheim	aa186a1ec2	Add eval to Expr/TypedExpr.	2021-06-02 10:21:41 +02:00
Kevin Leung	40d7c2fbde	Update badges	2021-05-22 12:07:27 +08:00
Kevin Leung	f1010a518f	Bump dependency and fix haxe3 compatibility	2021-05-14 21:33:09 +08:00
Kevin Leung	54f592f14c	Setup GitHub Actions	2021-05-14 21:29:25 +08:00
Juraj Kirchheim	e01bf6912a	Improve VarAccess to String conversion.	2021-05-03 20:38:55 +02:00
Juraj Kirchheim	56fe8d7346	Release 0.23.0	2021-04-02 10:09:41 +02:00
Juraj Kirchheim	7e2dfad607	Make TypeMap work exacly with anons.	2021-03-14 13:25:20 +01:00
Juraj Kirchheim	94d02c91a8	Haxe 3 support.	2021-03-14 12:59:38 +01:00
Juraj Kirchheim	99a1fc3fa6	Exact type to string conversion.	2021-03-14 12:58:10 +01:00
Juraj Kirchheim	a383f7692b	Argh ...	2021-02-25 11:37:04 +01:00
Juraj Kirchheim	5e5781e8bc	Faster intersection for haxe4.	2021-02-25 11:36:26 +01:00
Juraj Kirchheim	63ce1853f5	Release 0.22.0	2021-02-22 11:46:09 +01:00
Juraj Kirchheim	f3ddaa6496	Merge pull request #33 from haxetink/deduce_common_type Deduce common base type from a list of types	2020-12-23 09:32:31 +01:00
Kevin Leung	f46e49ce66	Fix haxe3	2020-12-22 17:15:28 +08:00
Kevin Leung	007c73d58e	Deduce common base type from a list of types	2020-12-22 16:56:45 +08:00
Juraj Kirchheim	8c5903833c	Merge pull request #32 from haxetink/isAbstract haxe 4.2+ fix	2020-12-20 09:21:31 +01:00
Dan Korostelev	59d7407d1b	haxe 4.2+ fix	2020-12-19 22:58:31 +01:00
Juraj Kirchheim	0680220a77	Release 0.21.1	2020-08-20 13:09:07 +02:00
Juraj Kirchheim	acaedc170a	Fix issue with build field retrieval.	2020-08-20 13:08:28 +02:00
Juraj Kirchheim	8b9dbba624	Release 0.21.0	2020-08-20 12:47:53 +02:00
Juraj Kirchheim	f9348d4a46	Release 0.20.2	2020-08-20 12:46:40 +02:00
Juraj Kirchheim	6f4e6b9227	Workaround https://github.com/HaxeFoundation/haxe/issues/9853	2020-08-20 12:45:33 +02:00
Juraj Kirchheim	59135d5cea	Release 0.20.1	2020-08-12 23:14:38 +02:00
Juraj Kirchheim	4accf55b41	Avoid messing with typing order.	2020-08-12 23:10:43 +02:00
Juraj Kirchheim	fd3b01ef0f	Release 0.20.0	2020-08-12 14:25:07 +02:00
Juraj Kirchheim	5825c2b617	Add TypedExpr helpers.	2020-08-12 14:22:00 +02:00
Juraj Kirchheim	328a8476a5	Release 0.19.3	2020-06-26 15:26:51 +02:00
Juraj Kirchheim	1589665652	Fix haxe 3.	2020-06-26 15:24:00 +02:00
Juraj Kirchheim	08f15a6739	Release 0.19.2	2020-06-26 15:09:56 +02:00
Juraj Kirchheim	b5e992b820	Fix issues in ComplexType -> Type conversion for functions.	2020-06-26 15:09:21 +02:00
Juraj Kirchheim	8c50dcf04b	Release 0.19.1	2020-04-29 20:58:00 +02:00
Juraj Kirchheim	4bc63c6eb0	Resolves #23 .	2020-04-24 15:55:39 +02:00
Juraj Kirchheim	acb7237ae4	Resolves #12 . Resolves #18 .	2020-04-24 15:38:51 +02:00
Juraj Kirchheim	e3bac681ce	Allow for typemaps that reduce everything except null.	2020-04-24 15:29:24 +02:00
Juraj Kirchheim	34516086c9	Update setup.	2020-04-24 14:42:55 +02:00
Kevin Leung	b1e7bf51cf	Release 0.19.0	2020-03-11 14:01:21 +08:00
Juraj Kirchheim	d5186f2fa2	Merge pull request #29 from haxetink/no-reflection No reflection	2020-01-09 07:50:25 +01:00
Juraj Kirchheim	8890b62b46	Now we have it, I think ...	2020-01-06 14:53:06 +01:00
Juraj Kirchheim	cce63becd6	Whoops.	2020-01-06 14:40:38 +01:00
Juraj Kirchheim	a101378a4c	Try to be smarter about when bouncing initialization.	2020-01-06 14:35:26 +01:00
Juraj Kirchheim	b48b300cbc	Add some missing cases in type mapping.	2020-01-04 15:45:29 +01:00
Juraj Kirchheim	27c9b20330	Get rid of all reflection.	2020-01-04 14:20:40 +01:00
Juraj Kirchheim	b4fa5f4fe0	Update lix version to download correct nightly.	2019-09-13 09:45:24 +02:00
Juraj Kirchheim	e59fab499d	Release 0.18.0	2019-09-13 09:40:22 +02:00
Juraj Kirchheim	3356172b7f	Update to newest haxe version.	2019-09-13 09:39:24 +02:00
Juraj Kirchheim	4fd03ed667	Release 0.17.7	2019-06-29 11:27:39 +02:00
Juraj Kirchheim	4cb5ee4196	Use @:persistent as necessary.	2019-06-22 15:16:04 +02:00
Kevin Leung	888481094a	Pin lix version	2019-05-14 11:33:28 +08:00
Kevin Leung	7686fe3e35	Use xenial	2019-05-14 11:10:52 +08:00
Kevin Leung	747d07bfc5	Revert "Better type comparison (closes #25 )" This reverts commit `00640d8328`.	2019-05-13 18:53:42 +08:00
Kevin Leung	00640d8328	Better type comparison (closes #25 )	2019-05-13 17:01:54 +08:00
Kevin Leung	77973f6007	print metadata	2019-05-13 17:00:54 +08:00
Juraj Kirchheim	0df9c28ace	Release 0.17.6	2019-05-07 22:43:21 +02:00
Juraj Kirchheim	d90fb966d2	Add call to find main class.	2019-05-07 22:42:39 +02:00
Kevin Leung	9018b06279	Release 0.17.5	2019-04-27 20:54:09 +08:00
Kevin Leung	6ed0424093	Convert TypeParameter to TypeParam	2019-04-23 18:21:03 +08:00
Juraj Kirchheim	53868cc6f3	Some fumbling with isSubTypeOf and add test for final.	2019-03-03 17:13:04 +01:00
Juraj Kirchheim	296cc6c861	Support final access on haxe4. Resolves #17 .	2019-03-03 12:24:22 +01:00
Juraj Kirchheim	56c2ed9642	Don't do setter bypass if it's not really necessary.	2019-03-03 12:18:40 +01:00
Juraj Kirchheim	ac908bc82d	Deal with somewhat obscure haxe 4 issue.	2019-03-03 12:18:07 +01:00
Juraj Kirchheim	1604a135ae	Expose compiler args and completion point.	2019-02-26 16:01:39 +01:00
Juraj Kirchheim	5e65f5354f	Add unification helper.	2019-02-24 08:25:04 +01:00
Juraj Kirchheim	8f81256731	Deal with null monos.	2019-02-24 08:24:50 +01:00
Kevin Leung	1b717919fa	Release 0.17.4	2019-02-24 09:28:59 +08:00
Kevin Leung	3d9aec835e	Merge pull request #24 from kevinresol/type_get_pos Get Position from a Type	2019-02-24 00:26:07 +08:00
Kevin Leung	86fa47eb0d	Get Position from a Type	2019-02-23 22:37:17 +08:00
Juraj Kirchheim	b5605e48ac	Use nightly rather than latest.	2019-02-01 17:44:53 +01:00
Juraj Kirchheim	6f5eba983e	Update travix.	2019-01-02 17:27:10 +01:00
Juraj Kirchheim	d5a44a9268	Release 0.17.3	2019-01-02 17:08:03 +01:00
Juraj Kirchheim	a11804c3ab	Merge branch 'master' of https://github.com/haxetink/tink_macro	2019-01-02 16:59:06 +01:00
Juraj Kirchheim	380ceb39ea	Add helper for transforming TypeParameter to TypeParamDecl.	2019-01-02 16:58:42 +01:00
Juraj Kirchheim	c48d445a54	Don't use get_field/set_field for field access anymore.	2018-11-08 11:27:37 +01:00
Juraj Kirchheim	b7e413d839	Release 0.17.2	2018-10-05 09:23:32 +02:00
Juraj Kirchheim	e1e487079b	Add Exprs.as for ECheckType.	2018-10-03 11:50:21 +02:00
Juraj Kirchheim	5f959f788e	Release 0.17.1	2018-10-02 09:12:28 +02:00
Juraj Kirchheim	4f84570bb7	Improve type parameter treatment.	2018-10-01 16:10:45 +02:00
Juraj Kirchheim	e398d0e694	Add helper for getting field suggestions.	2018-10-01 16:10:34 +02:00
Juraj Kirchheim	13d11f4f66	Make type comparator available.	2018-09-22 10:12:02 +02:00
Kevin Leung	d6142847eb	Update ci script	2018-09-19 16:40:12 +08:00
Kevin Leung	e6a0304016	Release 0.17.0	2018-09-08 14:14:22 +08:00
Kevin Leung	69368937a4	let lix manage travix	2018-09-08 13:59:47 +08:00
Kevin Leung	df2389d2c8	Merge branch 'master' of https://github.com/haxetink/tink_macro	2018-09-08 13:53:37 +08:00
Kevin Leung	aad80afec2	Standardize build script	2018-09-08 13:53:27 +08:00
Juraj Kirchheim	b68c6ac4a1	Fix complex type intersection.	2018-09-03 18:49:08 +02:00
Juraj Kirchheim	682aeacce8	Add ComplexType::intersect.	2018-09-01 15:09:05 +02:00
Juraj Kirchheim	9bcec770eb	Update travix.	2018-09-01 15:08:53 +02:00
Juraj Kirchheim	2310b6d8e4	Release 0.16.7	2018-08-23 11:24:32 +02:00
Kevin Leung	7f13916154	Fix haxe version check	2018-08-22 21:40:17 +08:00
Juraj Kirchheim	2b7204f8d3	Release 0.16.6	2018-07-26 12:57:57 +02:00
Juraj Kirchheim	7ca0d4a650	Merge branch 'master' of https://github.com/haxetink/tink_macro	2018-07-26 12:57:08 +02:00
Juraj Kirchheim	e38f5ae147	Expand metadata API of member.	2018-07-26 12:55:05 +02:00
Juraj Kirchheim	4186225eb5	Add haxe3 polyfill for ObjectField.	2018-07-26 12:54:31 +02:00
Juraj Kirchheim	f5a3d73c55	Merge pull request #22 from kLabz/fix/constructor-without-expr Fix ClassBuilder's getConstructor() when super class is extern	2018-05-08 16:33:51 +02:00
k	f65df0e94b	Fix ClassBuilder's getConstructor() when super class is extern Handle super class constructor's expr being `null`, which happens when the super class is an extern with a constructor definition.	2018-05-08 16:23:12 +02:00
Juraj Kirchheim	55a4b1463f	Release 0.16.5	2018-04-07 04:04:16 +02:00
Juraj Kirchheim	0a6e39969b	Fix direct initialization.	2018-04-07 04:03:09 +02:00
Juraj Kirchheim	f051345863	Various little fixes.	2018-04-02 13:06:42 +02:00
Juraj Kirchheim	74e37b4bf1	Release 0.16.4	2018-03-29 11:08:49 +02:00
Juraj Kirchheim	42821979d9	Totally insane workaround for https://github.com/HaxeFoundation/haxe/issues/5039	2018-03-29 02:00:05 +02:00
Juraj Kirchheim	2aa0b07e9f	Helper for short identifiers.	2018-03-29 01:59:27 +02:00
Juraj Kirchheim	67e680f67f	Release 0.16.3	2018-03-12 11:17:12 +01:00
Juraj Kirchheim	ebade45e63	Maintain Haxe 3 nullability semantics in Haxe 4.	2018-03-12 11:16:13 +01:00
Juraj Kirchheim	40497bb1fc	Fix tests for Haxe 3.2.1.	2018-01-31 20:36:10 +01:00
Juraj Kirchheim	d80b03fe9d	Release 0.16.2	2018-01-31 16:06:27 +01:00
Juraj Kirchheim	f269d13abf	Add workaround for HaxeFoundation/haxe#6830 .	2018-01-31 15:43:52 +01:00
Juraj Kirchheim	f271cc880a	Release 0.16.1	2018-01-29 10:12:58 +01:00
Juraj Kirchheim	9cd59d3989	Handle module types properly.	2018-01-29 10:12:06 +01:00
Juraj Kirchheim	40ee99df39	Lixify dependencies.	2018-01-29 10:11:50 +01:00
Juraj Kirchheim	1cb27daf46	Fix tests for Haxe 4.	2018-01-16 17:21:27 +01:00
Juraj Kirchheim	a9bea4287a	Fix headline structure.	2018-01-16 17:20:24 +01:00
Juraj Kirchheim	0be2090232	Release 0.16.0	2018-01-16 17:14:42 +01:00
Juraj Kirchheim	0dc774db21	Add support for scoping.	2017-12-24 12:23:10 +01:00
Juraj Kirchheim	a7c22bf5af	Return bulk added members from ClassBuilder.	2017-12-18 14:26:25 +01:00
Juraj Kirchheim	a164b335ed	Improve Type to ComplexType conversion for type parameters.	2017-12-18 11:28:23 +01:00
Juraj Kirchheim	d02306eebd	Add class reification shorthand to ClassBuilder.	2017-12-18 11:27:59 +01:00
Juraj Kirchheim	ff9ef59445	Expose more logic from BuildCache.	2017-12-18 11:27:32 +01:00
Juraj Kirchheim	bfc5c2b88f	Factor out build cache's param retrieval into separate function.	2017-12-15 12:27:01 +01:00
Juraj Kirchheim	57042819b1	Release 0.15.4	2017-12-08 10:41:26 +01:00
Juraj Kirchheim	82d15d9ffc	Report invalid type in getFields.	2017-12-08 10:40:24 +01:00
Juraj Kirchheim	0d9fff7e01	Reverse order in setter bypass to make type inference suffer less.	2017-12-06 17:13:01 +01:00
Juraj Kirchheim	45d5f3e0ea	Release 0.15.3	2017-12-01 16:32:19 +01:00
Juraj Kirchheim	800891bee2	Fixes #21 .	2017-12-01 16:31:22 +01:00
Juraj Kirchheim	0802bf7f79	Minor tweak.	2017-12-01 16:30:42 +01:00
Juraj Kirchheim	42897c7cd5	Merge branch 'master' of https://github.com/haxetink/tink_macro	2017-11-30 13:05:06 +01:00
Juraj Kirchheim	0e902745b1	Release 0.15.2	2017-11-30 13:04:39 +01:00
Juraj Kirchheim	3dec4fa404	Improve position reporting.	2017-11-30 13:04:07 +01:00
Juraj Kirchheim	c0ec918f52	Merge pull request #20 from markknol/patch-1 Update README.md	2017-11-30 11:52:41 +01:00
Mark Knol	4eb9729f0e	Update README.md Fix links in index	2017-11-30 10:56:14 +01:00
Juraj Kirchheim	7586b54ece	Release 0.15.1	2017-11-30 10:40:31 +01:00
Juraj Kirchheim	21c7d12be7	Don't drop positions when typing.	2017-11-30 10:39:57 +01:00
Juraj Kirchheim	f27d2796b1	Release 0.15.0	2017-09-25 10:52:48 +02:00
Juraj Kirchheim	417a92cabc	Make it compile for Haxe 4.	2017-09-25 10:50:36 +02:00
Kevin Leung	4457ea7dee	readme tweaks	2017-09-21 15:02:16 +08:00
Juraj Kirchheim	209847e5ea	Release 0.14.2	2017-09-11 10:36:42 +02:00
Juraj Kirchheim	c94e4a0337	Add way to get constructor args.	2017-09-11 10:35:54 +02:00
Juraj Kirchheim	cc009b2026	Release 0.14.1	2017-08-28 15:02:56 +02:00
Juraj Kirchheim	0a36ee8e2b	Merge pull request #16 from ibilon/haxe4 Support for haxe 4 EIn change to EBinop(OpIn)	2017-08-18 16:00:37 +02:00
Juraj Kirchheim	5879773566	Fix typo.	2017-08-18 15:41:31 +02:00
Juraj Kirchheim	58262a1810	Use reification to abstract over Haxe version specific differences.	2017-08-18 15:38:58 +02:00
Valentin Lemière	9ceadeb88f	Support for haxe 4 EIn change to EBinop(OpIn)	2017-08-18 15:13:28 +02:00
Juraj Kirchheim	15d75965ad	Release 0.14.0	2017-06-05 10:13:08 +02:00
Juraj Kirchheim	c7634e0a29	Just use Error.rethrow	2017-06-01 13:14:39 +02:00
Juraj Kirchheim	49e48bc801	Merge pull request #15 from Simn/eval don't use neko.Lib.rethrow when not in neko	2017-06-01 13:06:27 +02:00
Simon Krajewski	c150b84f18	don't use neko.Lib.rethrow when not in neko	2017-06-01 13:01:52 +02:00
Kevin Leung	04f86ce341	official gitter badge [ci skip]	2017-05-26 07:59:52 +08:00
Kevin Leung	45380371d8	Add badge [ci skip]	2017-05-19 17:54:35 +08:00
Juraj Kirchheim	d94d946301	Update README.md	2017-05-18 13:43:49 +02:00
Juraj Kirchheim	56b7caaf01	Release 0.13.5	2017-05-06 12:42:01 +02:00
Juraj Kirchheim	73e9da8435	Fix 3.2.1.	2017-04-13 21:07:44 +02:00
Juraj Kirchheim	bf23337923	Release 0.13.4	2017-04-13 21:04:00 +02:00
Juraj Kirchheim	02bd3bf69d	Add Types.getMeta.	2017-04-13 21:02:58 +02:00
Juraj Kirchheim	82a3417b97	Gitignore.	2017-04-13 20:58:16 +02:00
Juraj Kirchheim	1f986c3732	VSCode setup.	2017-04-13 20:57:29 +02:00
Kevin Leung	20e998fd12	Release 0.13.3	2017-03-20 20:01:41 +08:00
Kevin Leung	0f9c0d1e97	what the haxe?	2017-03-20 19:49:21 +08:00
Kevin Leung	2ae13d534e	my turn	2017-03-20 19:41:16 +08:00
back2dos	65d341f1e1	"push and read travis log" is the best kind of debugging ...	2017-03-20 11:50:32 +01:00
back2dos	68fa50c7c3	Let's see if we can fix that.	2017-03-20 11:32:50 +01:00
back2dos	32aa2d6570	Bump version.	2017-03-20 11:20:59 +01:00
back2dos	d81642e733	Use travix release.	2017-03-20 11:19:49 +01:00
Juraj Kirchheim	d5f4987ddb	Release 0.13.1	2017-03-16 16:31:14 +01:00
Juraj Kirchheim	671f1bc995	Merge pull request #11 from haxetink/kevinresol-patch-1 Add TypeMap alias	2017-03-16 16:02:34 +01:00
Kevin Leung	e06c40325b	Add TypeMap alias	2017-03-04 22:33:13 +08:00