Detecting types derived from array#289
Conversation
Perryvw
left a comment
There was a problem hiding this comment.
Would be nice if you could add one or two tests for this.
|
I added a translation test to see if the array base detection is working. Doing so I noticed that it won't work if the derived array class is generic, e.g. |
|
I prefer functional unit tests over translation tests. You can find bases of generic types using type.typeName/type.typeArguments, try putting |
I added a unit test for the derived array type.
Won't type.typeArguments just give me the generic's argument though? |
src/TSHelper.ts
Outdated
| return [false, null, null]; | ||
| } | ||
|
|
||
| public static isDefaultArrayCallExpression(node: ts.CallExpression, |
There was a problem hiding this comment.
I would just pass in a string and implement this as a Set.has(functionString), then do the transpilation before passing in the value. I don't think there is any real need for the actual node over the function name in this function?
There was a problem hiding this comment.
Sure, that would work as well. In this case I replicated the implementation of transpiler.transpileArrayCallExpression to match the existing coding style.
There was a problem hiding this comment.
The reason I don't like this is you are effectively moving part of the transpilation process into TSHelper, which is supposed to only contain helper methods for the transpiler.
|
Assignments.ts translation test was removed, please make sure your cases are covered by functional tests and remove the file from your branch too to solve the conflict. |
|
I changed |
* converting 'else if' statements to lua 'elseif' instead of nested ifs (#254) * Const enum support (#253) * Const enum support * Changed string concatenation to interpolation * refactored try block to allow rethrow (#251) * refactored try block to allow rethrow * updated rethrow test with something less convoluted * Made LuaJIT use table.unpack for destructing assignments (#257) * Fixed JIT using table.unpack (#258) * Fixed JIT using table.unpack sry * Fixed test for JIT unpack * Moved transpileDestructingAssignmentValue from 5.1 to 5.0 * Moved transpile switch to Lua 5.2 (#259) * Moved transpile switch to Lua 5.2 Closes #194 * Fixed typo * Cleaned up ForOf code (#260) * Cleaned up forOf loop, made it use numeric loop instead of ipairs * Fixed bug in non-array loop header and fixed tests * Fixed up some PR comments * passing nil instead of _G as context for global functions when in ES strict mode * fixed logic for determining strict mode * replaced hack-around when passing nil as a function context with a null keyword * testing viability of wrapping context/no-context calls on assignment * working on more function assignment situations * Fix error in module namespace enum exporting (#272) * fixed getting constructor signature and refactored things a bit * checking resolved signature when comparing function types passed as arguments * 0.11.0 * Update CHANGELOG.md * Luajit unpack fix (#273) * LuaJIT uses LuaTranspiler's spread * Added some unit tests for spreading * Stopped using prototype * Removed Transpiler import * Fixed constructor overloads (#275) * Fixed constructor overloads Fixes #274 * Removed lambda body * Removed transpileFile (should be added to changelog since this was exposed in the API) * Lualib omit when unused (#280) * lualib inline omit header when no features are used * Tests to enforce no lualib text when unused, unless using always * Fixed bug with default values for constructor parameters * 0.11.1 * working on assignment checks for methods vs functions * handling context in calls and decls * refactoring and handling tuple destructuring * generalized tuple assignment checking * overloads with function and method signatures default to functions now * preventing non-methods from being passed to bind/call/apply * removed uneccessary helpers * using proper exceptions for function conversion errors * removed context arg from custom constructors and added check for assigning to untyped vars * updated tests * removing leftover NoContext decorators * Added discord badge and link to readme * Added support for JSDoc tags as decorators * Fixed invalid jsdoc failing a test * Added deprecation warning for ! decorators * Refactored decorator creation, made decorators case-insensitive * Fixed jsdoc tests * Fixed test runner not failing * recursing into interfaces during assignment validation * Update README.md * fixes for issues with overloads using different context types * Fixed casing and symbol of decorators to be consistent with the new convention * less-lazy variable naming and improved error message * removing assignments translation test (#296) * Create CONTRIBUTING.md * Update README.md * Detecting types derived from array (#289) * check the base types to determine if a type inherits from Array<T> * dont block exceptions * remove empty else clause * remove space * added tsHelper.isDefaultArrayCallExpression() * added derived array recognition test code * Added isExplicitArrayType() method * added unit test * rewrite isDefaultArrayCall() -> isDefaultArrayCallMethodName() * change switch statement to Set<string> lookup * 0.12.0 * stabilize package lock * Check inherited accessors (#297) * check for inherited accessor methods * diversify test * removed FocusTests and repositioned forAllTypes * rename forTypeOrAnySupertype * Fixed default constructor on subclass (#301) * Use declared types (#302) * update forTypeOrAnySupertype() to use declared type * added test case for accessor using this * enhance test to use generics * 0.12.1 * suite of tests for new functions and fixes for edge-cases found * validating return values and hanlding inference of contexts when passing functions as arguments or return values * renamed getFunctionReturnType to getContainingFunctionReturnType * handling more edge cases, adding more tests and a little bit of refactoring
Allow the transpiler to detect types derived from array. This allows us to easily create interfaces for array-like types implemented in lua and get a coherent typescript-style interface while retaining the original functionality.
Oversimplified example
An array with a clear method:
Typescript interface:
Usage: