mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-11-21 18:39:56 +01:00
1923 lines
70 KiB
ObjectPascal
1923 lines
70 KiB
ObjectPascal
unit tctsparser;
|
|
|
|
{$mode ObjFPC}{$H+}
|
|
|
|
interface
|
|
|
|
uses
|
|
Classes, SysUtils, testregistry, tcparser, jsscanner, jsbase, jstree, jstoken;
|
|
|
|
Type
|
|
|
|
{ TTestTypeScriptParser }
|
|
|
|
TTestTypeScriptParser = Class(TTestBaseJSParser)
|
|
private
|
|
Public
|
|
Procedure StartTS(aSource : String);
|
|
procedure CheckMembers(M : TJSSourceElements; aVars,aFunctions,aStatements,aClasses,aModules,aNamespaces,aTypes : Integer);
|
|
Published
|
|
Procedure TestDeclareModule;
|
|
Procedure TestDeclareModuleIdentifier;
|
|
Procedure TestDeclareNamespace;
|
|
Procedure TestDeclareGlobal;
|
|
Procedure TestDeclareUniqueConst;
|
|
Procedure TestDeclareFunction;
|
|
Procedure TestDeclareFunctionOptionalArg;
|
|
Procedure TestDeclareFunctionSpreadArg;
|
|
Procedure TestDeclareFunctionLiteralArg;
|
|
Procedure TestDeclareTypeAlias;
|
|
Procedure TestDeclareTypeAliasDotted;
|
|
Procedure TestDeclareTypeTypeQuery;
|
|
Procedure TestDeclareTypeUnion;
|
|
Procedure TestDeclareTypeUnionConsts;
|
|
Procedure TestDeclareTypeUnionAllowEmpty;
|
|
Procedure TestDeclareUnionTuple;
|
|
Procedure TestDeclareUnionIntersectionType;
|
|
Procedure TestDeclareTypeTuple;
|
|
Procedure TestDeclareTypeArray;
|
|
Procedure TestDeclareTypeArrayOfUnionType;
|
|
Procedure TestDeclareTypeArrayOfFunctionType;
|
|
Procedure TestDeclareTypeArrayGeneric;
|
|
Procedure TestDeclareTypeArrayGenericConst;
|
|
Procedure TestDeclareTypeArrayKeyOf;
|
|
Procedure TestDeclareTypeGeneric;
|
|
Procedure TestDeclareTypeGenericGeneric;
|
|
Procedure TestDeclareTypeGenericNested;
|
|
procedure TestDeclareTypeGenericNestedTwice;
|
|
Procedure TestDeclareTypeGenericAssigned;
|
|
Procedure TestDeclareTypeGenericConstSubtype;
|
|
Procedure TestDeclareTypeObject;
|
|
Procedure TestDeclareTypeObjectLineBreak;
|
|
Procedure TestDeclareTypeObjectPropRef;
|
|
procedure TestDeclareTypeObjectIndexSignature;
|
|
Procedure TestDeclareTypeArrowFunction;
|
|
Procedure TestDeclareTypeArrowFunctionShort;
|
|
Procedure TestDeclareTypeArrowFunctionTwoArgs;
|
|
Procedure TestDeclareTypeArrowFunctionArgsCommaEnd;
|
|
procedure TestDeclareTypeGenericConstraint;
|
|
procedure TestDeclareTypeTypeImport;
|
|
procedure TestDeclareTypeTypeOfImport;
|
|
procedure TestDeclareTypeTypeOfDefault;
|
|
procedure TestDeclareTypeReadonly;
|
|
procedure TestDeclareArgTypeInferred;
|
|
Procedure TestDeclareEnum;
|
|
Procedure TestDeclareEnumKeywordElement;
|
|
Procedure TestDeclareConstEnum;
|
|
Procedure TestDeclareConstEnumAssigned;
|
|
procedure TestDeclareInterfaceEmpty;
|
|
procedure TestDeclareAmbientInterfaceEmpty;
|
|
procedure TestDeclareInterfaceExtendsEmpty;
|
|
procedure TestDeclareInterfaceExtendsTwoEmpty;
|
|
procedure TestDeclareInterfaceProperty;
|
|
procedure TestDeclareInterfaceOptionalProperty;
|
|
procedure TestDeclareInterfaceUntypedProperty;
|
|
procedure TestDeclareInterfaceOptionalUntypedProperty;
|
|
procedure TestDeclareInterfaceMethod;
|
|
procedure TestDeclareInterfaceMethodNoReturn;
|
|
procedure TestDeclareInterfaceCallable;
|
|
procedure TestDeclareInterfaceMethodThisReturn;
|
|
procedure TestDeclateInterfaceGenericProperty;
|
|
procedure TestDeclateInterfaceGeneric;
|
|
procedure TestDeclareInterfaceExtendsGeneric;
|
|
Procedure TestDeclareInterfaceHidden;
|
|
procedure TestDeclareClassEmpty;
|
|
procedure TestDeclareAbstractClassEmpty;
|
|
procedure TestDeclareClassIndexSignature;
|
|
procedure TestDeclareClassIndexSignatureIn;
|
|
procedure TestDeclareClassExtendsGeneric;
|
|
procedure TestDeclareClassGeneric;
|
|
procedure TestDeclareClassStaticFunction;
|
|
procedure TestDeclareClassStaticFunctionUntypedArg;
|
|
procedure TestDeclareClassStaticReadonlyProperty;
|
|
procedure TestDeclareClassReadonlyProperty;
|
|
procedure TestDeclareClassGenericFunctionProperty;
|
|
procedure TestDeclareClassImplements;
|
|
procedure TestDeclareClassExtendsFunctionCall;
|
|
Procedure TestDeclareClassStaticReadOnly;
|
|
procedure TestDeclareInterfaceIndexSignature;
|
|
procedure TestDeclareInterfaceFixedStringProperty;
|
|
procedure TestDeclareInterfaceFixedBooleanProperty;
|
|
procedure TestDeclareInterfaceFixedUnionProperty;
|
|
procedure TestDeclareInterfaceDestructuredFunctionProperty;
|
|
procedure TestDeclareInterfaceNoSemicolon;
|
|
procedure TestDeclareConstructorSignature;
|
|
procedure TestDeclareFunctionDestructuredParam;
|
|
procedure TestDeclareFunctionIs;
|
|
procedure TestDeclareFunctionThisParam;
|
|
procedure TestExportNamespacedClass;
|
|
procedure TestExportAbstractClass;
|
|
procedure TestExportClassConstructor;
|
|
procedure TestExportInterface;
|
|
procedure TestExportInterfaceDefault;
|
|
procedure TestExportInterfaceIndexSignature;
|
|
procedure TestExportInterfaceIndexSignatureOptional;
|
|
procedure TestExportImportStatement;
|
|
procedure TestExportAssignStatement;
|
|
procedure TestExportAsNamespace;
|
|
procedure TestExportNamespaceClass;
|
|
procedure TestExportDefaultFunction;
|
|
procedure TestExportFunction;
|
|
procedure TestExportTypeArrowFunctionArgsComma;
|
|
procedure TestDeclareExportInterfaceDestructuredFunctionProperty;
|
|
procedure TestExportEnum;
|
|
procedure TestExportObjectUnion;
|
|
Procedure TestExportNoSemicolon;
|
|
Procedure TestExportAsKeyWord;
|
|
procedure TestNamespaceInterfaceFUnction;
|
|
end;
|
|
|
|
implementation
|
|
|
|
{ TTestTypeScriptParser }
|
|
|
|
procedure TTestTypeScriptParser.StartTS(aSource: String);
|
|
begin
|
|
CreateParser(aSource,ecma2021,True);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.CheckMembers(M : TJSSourceElements; aVars, aFunctions, aStatements, aClasses, aModules, aNamespaces,aTypes: Integer);
|
|
begin
|
|
AssertEquals('functions count',aFunctions,M.Functions.Count);
|
|
AssertEquals('vars count',aVars,M.Vars.Count);
|
|
AssertEquals('Statements count',aStatements,M.Statements.Count);
|
|
AssertEquals('classes count',aClasses,M.Classes.Count);
|
|
AssertEquals('namespaces count',aNamespaces,M.NameSpaces.Count);
|
|
AssertEquals('Modules count',aModules,M.Modules.Count);
|
|
AssertEquals('Types count',aTypes,M.Modules.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareModule;
|
|
|
|
Var
|
|
M : TJSModuleDeclaration;
|
|
|
|
begin
|
|
StartTS('declare module "a" { }');
|
|
M:=GetFirstModule;
|
|
AssertEquals('Name','a',M.Name);
|
|
CheckMembers(M.Members,0,0,0,0,0,0,0);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareModuleIdentifier;
|
|
|
|
Var
|
|
M : TJSModuleDeclaration;
|
|
|
|
begin
|
|
StartTS('declare module a { }');
|
|
M:=GetFirstModule;
|
|
AssertEquals('Name','a',M.Name);
|
|
CheckMembers(M.Members,0,0,0,0,0,0,0);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareNamespace;
|
|
Var
|
|
N : TJSNamespaceDeclaration;
|
|
|
|
begin
|
|
StartTS('declare namespace a { }');
|
|
N:=GetFirstNamespace;
|
|
AssertEquals('Name','a',N.Name);
|
|
CheckMembers(N.Members,0,0,0,0,0,0,0);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareGlobal;
|
|
Var
|
|
N : TJSNamespaceDeclaration;
|
|
|
|
begin
|
|
StartTS('declare global { }');
|
|
N:=GetFirstNamespace;
|
|
AssertEquals('Name','',N.Name);
|
|
AssertEquals('Global',True,N.IsGlobal);
|
|
CheckMembers(N.Members,0,0,0,0,0,0,0);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareUniqueConst;
|
|
|
|
Var
|
|
V : TJSVarDeclaration;
|
|
|
|
begin
|
|
StartTS('const A : unique symbol');
|
|
V:=TJSVarDeclaration(CheckClass('Var',TJSVarDeclaration,GetFirstVar));
|
|
AssertEquals('Unique ',True,V.IsUnique);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunction;
|
|
|
|
Var
|
|
F : TJSFunctionDeclarationStatement;
|
|
|
|
begin
|
|
StartTS('declare function a (b : number) : string ;');
|
|
F:=GetFirstFunction;
|
|
AssertEquals('Name','a',F.AFunction.Name);
|
|
AssertNull('No body',F.AFunction.Body);
|
|
AssertNotNull('Have params',F.AFunction.TypedParams);
|
|
AssertEquals('Param Count',1,F.AFunction.TypedParams.Count);
|
|
AssertEquals('Param 1 name','b',F.AFunction.TypedParams.Names[0]);
|
|
AssertEquals('Param 1 optional',False,F.AFunction.TypedParams.Params[0].IsOptional);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunctionOptionalArg;
|
|
Var
|
|
F : TJSFunctionDeclarationStatement;
|
|
|
|
begin
|
|
StartTS('declare function a (b ? : number) : string ;');
|
|
F:=GetFirstFunction;
|
|
AssertEquals('Name','a',F.AFunction.Name);
|
|
AssertNull('No body',F.AFunction.Body);
|
|
AssertNotNull('Have params',F.AFunction.TypedParams);
|
|
AssertEquals('Param Count',1,F.AFunction.TypedParams.Count);
|
|
AssertEquals('Param 1 name','b',F.AFunction.TypedParams.Names[0]);
|
|
AssertEquals('Param 1 optional',True,F.AFunction.TypedParams.Params[0].IsOptional);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunctionSpreadArg;
|
|
Var
|
|
F : TJSFunctionDeclarationStatement;
|
|
|
|
begin
|
|
StartTS('declare function a (...b ? : number) : string ;');
|
|
F:=GetFirstFunction;
|
|
AssertEquals('Name','a',F.AFunction.Name);
|
|
AssertNull('No body',F.AFunction.Body);
|
|
AssertNotNull('Have params',F.AFunction.TypedParams);
|
|
AssertEquals('Param Count',1,F.AFunction.TypedParams.Count);
|
|
AssertEquals('Param 1 name','b',F.AFunction.TypedParams.Names[0]);
|
|
AssertEquals('Param 1 optional',True,F.AFunction.TypedParams.Params[0].IsOptional);
|
|
AssertEquals('Param 1 spread',True,F.AFunction.TypedParams.Params[0].IsSpread);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunctionLiteralArg;
|
|
Var
|
|
F : TJSFunctionDeclarationStatement;
|
|
R : TJSFixedValueReference;
|
|
|
|
begin
|
|
StartTS('declare function a (b : ''number'') : string ;');
|
|
F:=GetFirstFunction;
|
|
AssertEquals('Name','a',F.AFunction.Name);
|
|
AssertNull('No body',F.AFunction.Body);
|
|
AssertNotNull('Have params',F.AFunction.TypedParams);
|
|
AssertEquals('Param Count',1,F.AFunction.TypedParams.Count);
|
|
AssertEquals('Param 1 name','b',F.AFunction.TypedParams.Names[0]);
|
|
AssertEquals('Param 1 optional',False,F.AFunction.TypedParams.Params[0].IsOptional);
|
|
AssertEquals('Param 1 spread',False,F.AFunction.TypedParams.Params[0].IsSpread);
|
|
AssertNotNull('Param 1 type',F.AFunction.TypedParams.Types[0]);
|
|
R:=TJSFixedValueReference(CheckClass('Param 1 type',TJSFixedValueReference,F.AFunction.TypedParams.Types[0]));
|
|
AssertNotNull('Have Fixedvalue',R.FixedValue);
|
|
AssertNotNull('Have Fixedvalue.Value',R.FixedValue.Value);
|
|
AssertEquals('Fixed value','number',R.FixedValue.Value.AsString);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeAlias;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
|
|
begin
|
|
StartTS('type a = b;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSTypeReference,T.TypeDef.ClassType);
|
|
AssertEquals('Correct name def class','b',TJSTypeReference(T.TypeDef).Name);
|
|
AssertEquals('Correct IsTypeOf',False,TJSTypeReference(T.TypeDef).IsTypeOf);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeAliasDotted;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
|
|
begin
|
|
StartTS('type a = b.c;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSTypeReference,T.TypeDef.ClassType);
|
|
AssertEquals('Correct name def class','b.c',TJSTypeReference(T.TypeDef).Name);
|
|
AssertEquals('Correct isTypeOf',False,TJSTypeReference(T.TypeDef).IsTypeOf);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeTypeQuery;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
|
|
begin
|
|
StartTS('type a = typeof b;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSTypeReference,T.TypeDef.ClassType);
|
|
AssertEquals('Correct name def class','b',TJSTypeReference(T.TypeDef).Name);
|
|
AssertEquals('Correct name def class',True,TJSTypeReference(T.TypeDef).IsTypeOf);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeUnion;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
U : TJSUnionTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = string | number');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSUnionTypeDef,T.TypeDef.ClassType);
|
|
U:=TJSUnionTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2,U.TypeCount);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, U.Types[0].ClassType);
|
|
R:=U.Types[0] as TJSTypeReference;
|
|
AssertEquals('Name type 0','string',R.Name);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, U.Types[1].ClassType);
|
|
R:=U.Types[1] as TJSTypeReference;
|
|
AssertEquals('Name type 1','number',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeUnionConsts;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
U : TJSUnionTypeDef;
|
|
R : TJSFixedValueReference;
|
|
|
|
begin
|
|
StartTS('type a = "string" | "number"');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSUnionTypeDef,T.TypeDef.ClassType);
|
|
U:=TJSUnionTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2,U.TypeCount);
|
|
AssertEquals('Correct type of element 0',TJSFixedValueReference, U.Types[0].ClassType);
|
|
R:=U.Types[0] as TJSFixedValueReference;
|
|
AssertEquals('Name type 0','string',R.FixedValue.Value.AsString);
|
|
AssertEquals('Correct type of element 0',TJSFixedValueReference, U.Types[1].ClassType);
|
|
R:=U.Types[1] as TJSFixedValueReference;
|
|
AssertEquals('Name type 1','number',R.FixedValue.Value.AsString);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeUnionAllowEmpty;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
U : TJSUnionTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = | string | number');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSUnionTypeDef,T.TypeDef.ClassType);
|
|
U:=TJSUnionTypeDef(T.TypeDef);
|
|
AssertEquals('Allow empty ',True,U.AllowEmpty);
|
|
AssertEquals('Correct number of elements',2,U.TypeCount);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, U.Types[0].ClassType);
|
|
R:=U.Types[0] as TJSTypeReference;
|
|
AssertEquals('Name type 0','string',R.Name);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, U.Types[1].ClassType);
|
|
R:=U.Types[1] as TJSTypeReference;
|
|
AssertEquals('Name type 1','number',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareUnionTuple;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
begin
|
|
StartTS('declare type Color = string | [number, number, number, number] | ColorObject;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','Color',T.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareUnionIntersectionType;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
U : TJSUnionTypeDef;
|
|
|
|
begin
|
|
StartTs('declare type MyType = number | (string | number) ;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','MyType',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSUnionTypeDef,T.TypeDef.ClassType);
|
|
U:=TJSUnionTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2,U.TypeCount);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeTuple;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
U : TJSTupleTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = [string , number]');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSTupleTypeDef,T.TypeDef.ClassType);
|
|
U:=TJSTupleTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2,U.TypeCount);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, U.Types[0].ClassType);
|
|
R:=U.Types[0] as TJSTypeReference;
|
|
AssertEquals('Name type 0','string',R.Name);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, U.Types[1].ClassType);
|
|
R:=U.Types[1] as TJSTypeReference;
|
|
AssertEquals('Name type 1','number',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArray;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrayTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = string[]');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSArrayTypeDef,T.TypeDef.ClassType);
|
|
A:=TJSArrayTypeDef(T.TypeDef);
|
|
AssertNotNull('have base type',A.BaseType);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, A.BaseType.ClassType);
|
|
R:=A.BaseType as TJSTypeReference;
|
|
AssertEquals('Name base type','string',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrayOfUnionType;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrayTypeDef;
|
|
U : TJSUnionTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = (string | number)[]');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
A:=TJSArrayTypeDef(CheckClass(T.TypeDef,TJSArrayTypeDef,'Type def class'));
|
|
U:=TJSUnionTypeDef(CheckClass(A.BaseType,TJSUnionTypeDef,'base type Union class '));
|
|
AssertEquals('Union Count',2,U.TypeCount);
|
|
R:=TJSTypeReference(CheckClass(U.Types[0],TJSTypeReference,'Union class element 0'));
|
|
AssertEquals('Name base type','string',R.Name);
|
|
R:=TJSTypeReference(CheckClass(U.Types[1],TJSTypeReference,'Union class element 1'));
|
|
AssertEquals('Name base type','number',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrayOfFunctionType;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrayTypeDef;
|
|
F : TJSArrowFunctionTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = (() => string)[]');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
A:=TJSArrayTypeDef(CheckClass(T.TypeDef,TJSArrayTypeDef,'Type def class'));
|
|
F:=TJSArrowFunctionTypeDef(CheckClass(A.BaseType,TJSArrowFunctionTypeDef,'Have arrow function'));
|
|
AssertNotNull('Have function definition',F.aFunction);
|
|
R:=TJSTypeReference(CheckClass(F.aFunction.ResultType,TJSTypeReference,'Have function result'));
|
|
AssertEquals('result type name','string',R.Name);
|
|
AssertEquals('function argument count',0,F.aFunction.TypedParams.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrayKeyOf;
|
|
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrayTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = string[keyof B]');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSArrayTypeDef,T.TypeDef.ClassType);
|
|
A:=TJSArrayTypeDef(T.TypeDef);
|
|
AssertNotNull('have base type',A.BaseType);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, A.BaseType.ClassType);
|
|
R:=A.BaseType as TJSTypeReference;
|
|
AssertEquals('Name base type','string',R.Name);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, A.IndexType.ClassType);
|
|
R:=A.IndexType as TJSTypeReference;
|
|
AssertEquals('Name base type','B',R.Name);
|
|
AssertEquals('Keyof type',True,R.IsKeyOf);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrayGeneric;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrayTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = Array<string>');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSArrayTypeDef,T.TypeDef.ClassType);
|
|
A:=TJSArrayTypeDef(T.TypeDef);
|
|
AssertNotNull('have base type',A.BaseType);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, A.BaseType.ClassType);
|
|
R:=A.BaseType as TJSTypeReference;
|
|
AssertEquals('Name base type','string',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrayGenericConst;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrayTypeDef;
|
|
U : TJSUnionTypeDef;
|
|
|
|
begin
|
|
StartTS('type a = Array<"params" | "query" | "headers" | "body">;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSArrayTypeDef,T.TypeDef.ClassType);
|
|
A:=TJSArrayTypeDef(T.TypeDef);
|
|
AssertNotNull('have base type',A.BaseType);
|
|
AssertEquals('Correct type of base type',TJSUnionTypeDef, A.BaseType.ClassType);
|
|
U:=A.BaseType as TJSUnionTypeDef;
|
|
AssertEquals('Element count',4,U.TypeCount);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGeneric;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
G : TJSGenericTypeRef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = Shell<string>');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSGenericTypeRef,T.TypeDef.ClassType);
|
|
G:=TJSGenericTypeRef(T.TypeDef);
|
|
AssertNotNull('have base type',G.BaseType);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, G.BaseType.ClassType);
|
|
R:=G.BaseType as TJSTypeReference;
|
|
AssertEquals('Name base type','Shell',R.Name);
|
|
AssertEquals('Correct number of parameters',1, G.ParamTypeCount);
|
|
AssertEquals('Correct type of parameter 0',TJSTypeReference, G.ParamTypes[0].Classtype);
|
|
R:=G.ParamTypes[0] as TJSTypeReference;
|
|
AssertEquals('Name base type','string',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGenericGeneric;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
G : TJSTupleTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type Pair<T> = [T,T]');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','Pair',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct number of parameters',1, T.TypeParams.Count);
|
|
AssertEquals('Correct type of parameter 0',TJSTypeReference, T.TypeParams[0].Node.Classtype);
|
|
R:=T.TypeParams[0].Node as TJSTypeReference;
|
|
AssertEquals('Name base type','T',R.Name);
|
|
AssertEquals('Correct type def class',TJSTupleTypeDef,T.TypeDef.ClassType);
|
|
G:=TJSTupleTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of parameters',2, G.TypeCount);
|
|
AssertEquals('Correct type of parameter 0',TJSTypeReference, G.Types[0].Classtype);
|
|
R:=G.Types[0] as TJSTypeReference;
|
|
AssertEquals('Name base type','T',R.Name);
|
|
AssertEquals('Correct type of parameter 1',TJSTypeReference, G.Types[1].Classtype);
|
|
R:=G.Types[1] as TJSTypeReference;
|
|
AssertEquals('Name base type','T',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGenericNested;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
G : TJSGenericTypeRef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type a = A<Q,B<C>>;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSGenericTypeRef,T.TypeDef.ClassType);
|
|
G:=TJSGenericTypeRef(T.TypeDef);
|
|
AssertNotNull('have base type',G.BaseType);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, G.BaseType.ClassType);
|
|
R:=G.BaseType as TJSTypeReference;
|
|
AssertEquals('Name base type','A',R.Name);
|
|
AssertEquals('Correct number of parameters',2, G.ParamTypeCount);
|
|
// Arg 1
|
|
AssertEquals('Correct type of parameter 0',TJSTypeReference, G.ParamTypes[0].Classtype);
|
|
R:=G.ParamTypes[0] as TJSTypeReference;
|
|
AssertEquals('Name base type','Q',R.Name);
|
|
// Arg 2
|
|
AssertEquals('Correct type of base type',TJSGenericTypeRef, G.ParamTypes[1].Classtype);
|
|
G:=G.ParamTypes[1] as TJSGenericTypeRef;
|
|
AssertNotNull('have base type',G.BaseType);
|
|
AssertEquals('Correct type of base type',TJSTypeReference, G.BaseType.ClassType);
|
|
R:=G.BaseType as TJSTypeReference;
|
|
AssertEquals('Name base type','B',R.Name);
|
|
AssertEquals('Correct number of parameters',1, G.ParamTypeCount);
|
|
AssertEquals('Correct type of parameter 0',TJSTypeReference, G.ParamTypes[0].Classtype);
|
|
R:=G.ParamTypes[0] as TJSTypeReference;
|
|
AssertEquals('Name base type','C',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGenericNestedTwice;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
|
|
begin
|
|
StartTS('type a = A<Q<B<C<D>>>>;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','a',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type def class',TJSGenericTypeRef,T.TypeDef.ClassType);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGenericAssigned;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
R : TJSTypeReference;
|
|
P : TJSNamedParamTypeDef;
|
|
begin
|
|
StartTS('type TA<TEvent = any, TResult = any> = B;');
|
|
T:=TJSTypeDeclaration(CheckClass('First type',TJSTypeDeclaration,GetFirstType));
|
|
R:=TJSTypeReference(CheckClass('Correct type',TJSTypeReference,T.TypeDef));
|
|
AssertEquals('Name','B',R.Name);
|
|
AssertEquals('Type param count',2,T.TypeParams.Count);
|
|
// Param 1
|
|
P:=TJSNamedParamTypeDef(CheckClass('Param 1,',TJSNamedParamTypeDef,T.TypeParams.JSElements[0]));
|
|
R:=TJSTypeReference(CheckClass('Correct type',TJSTypeReference,P.ParamName));
|
|
AssertEquals('Name','TEvent',R.Name);
|
|
R:=TJSTypeReference(CheckClass('Correct type',TJSTypeReference,P.ParamType));
|
|
AssertEquals('Name','any',R.Name);
|
|
// Param 2
|
|
P:=TJSNamedParamTypeDef(CheckClass('Param 2,',TJSNamedParamTypeDef,T.TypeParams.JSElements[1]));
|
|
R:=TJSTypeReference(CheckClass('Correct type',TJSTypeReference,P.ParamName));
|
|
AssertEquals('Name','TResult',R.Name);
|
|
R:=TJSTypeReference(CheckClass('Correct type',TJSTypeReference,P.ParamType));
|
|
AssertEquals('Name','any',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGenericConstSubtype;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
G : TJSGenericTypeRef;
|
|
R : TJSTypeReference;
|
|
begin
|
|
StartTS('type StatusCodeMap = Record<string, "trace" | "debug" | "info" | "warn" | "error">');
|
|
T:=TJSTypeDeclaration(CheckClass('First type',TJSTypeDeclaration,GetFirstType));
|
|
AssertEquals('Name','StatusCodeMap',T.Name);
|
|
G:=TJSGenericTypeRef(CheckClass('Correct type',TJSGenericTypeRef,T.TypeDef));
|
|
R:=TJSTypeReference(CheckClass('Correct type',TJSTypeReference,G.BaseType));
|
|
AssertEquals('Name','Record',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeObject;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
O : TJSObjectTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type TreeItem = {left : TreeItem, right : TreeItem};');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','TreeItem',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type of typedef',TJSObjectTypeDef, T.TypeDef.ClassType);
|
|
O:=TJSObjectTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2, O.ElementCount);
|
|
AssertEquals('Correct name of element 0','left', O.Elements[0].Name);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, O.Elements[0].ElementType.ClassType);
|
|
R:=O.Elements[0].ElementType as TJSTypeReference;
|
|
AssertEquals('Name base type','TreeItem',R.Name);
|
|
AssertEquals('Correct name of element 0','right', O.Elements[1].Name);
|
|
AssertEquals('Correct type of element 1',TJSTypeReference, O.Elements[1].ElementType.ClassType);
|
|
R:=O.Elements[1].ElementType as TJSTypeReference;
|
|
AssertEquals('Name base type','TreeItem',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeObjectLineBreak;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
O : TJSObjectTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type TreeItem = {'#10+
|
|
'left : TreeItem'#10+
|
|
'right : TreeItem'#10+
|
|
'};');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','TreeItem',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type of typedef',TJSObjectTypeDef, T.TypeDef.ClassType);
|
|
O:=TJSObjectTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2, O.ElementCount);
|
|
AssertEquals('Correct name of element 0','left', O.Elements[0].Name);
|
|
AssertEquals('Correct type of element 0',TJSTypeReference, O.Elements[0].ElementType.ClassType);
|
|
R:=O.Elements[0].ElementType as TJSTypeReference;
|
|
AssertEquals('Name base type','TreeItem',R.Name);
|
|
AssertEquals('Correct name of element 0','right', O.Elements[1].Name);
|
|
AssertEquals('Correct type of element 1',TJSTypeReference, O.Elements[1].ElementType.ClassType);
|
|
R:=O.Elements[1].ElementType as TJSTypeReference;
|
|
AssertEquals('Name base type','TreeItem',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeObjectIndexSignature;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
O : TJSObjectTypeDef;
|
|
// R : TJSTypeReference;
|
|
SigDecl: TJSIndexSignatureDeclaration;
|
|
|
|
begin
|
|
StartTS('type TreeItem = { [x: string]: never, [x: number]: never };');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','TreeItem',T.Name);
|
|
AssertNotNull('Have type def',T.TypeDef);
|
|
AssertEquals('Correct type of typedef',TJSObjectTypeDef, T.TypeDef.ClassType);
|
|
O:=TJSObjectTypeDef(T.TypeDef);
|
|
AssertEquals('Correct number of elements',2, O.ElementCount);
|
|
SigDecl:=TJSIndexSignatureDeclaration(CheckClass('Index signature',TJSIndexSignatureDeclaration,O.Elements[0]));
|
|
AssertEquals('No name','',SigDecl.Name);
|
|
AssertEquals('Index type','string',SigDecl.IndexType);
|
|
end;
|
|
|
|
|
|
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrowFunction;
|
|
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrowFunctionTypeDef;
|
|
P : TJSTypedParam;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type CallBack = (data : t) => void;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','CallBack',T.Name);
|
|
A:=TJSArrowFunctionTypeDef(CheckClass(T.TypeDef,TJSArrowFunctionTypeDef,'Have arrow function'));
|
|
AssertNotNull('Have function definition',A.aFunction);
|
|
R:=TJSTypeReference(CheckClass(A.aFunction.ResultType,TJSTypeReference,'Have function result'));
|
|
AssertEquals('result type name','void',R.Name);
|
|
AssertEquals('function argument count',1,A.aFunction.TypedParams.Count);
|
|
P:=A.aFunction.TypedParams.Params[0];
|
|
AssertEquals('param name','data',P.Name);
|
|
R:=TJSTypeReference(CheckClass(P.Node,TJSTypeReference,'Have param type'));
|
|
AssertEquals('param type name','t',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrowFunctionShort;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrowFunctionTypeDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type CallBack = () => void;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','CallBack',T.Name);
|
|
A:=TJSArrowFunctionTypeDef(CheckClass(T.TypeDef,TJSArrowFunctionTypeDef,'Have arrow function'));
|
|
AssertNotNull('Have function definition',A.aFunction);
|
|
R:=TJSTypeReference(CheckClass(A.aFunction.ResultType,TJSTypeReference,'Have function result'));
|
|
AssertEquals('result type name','void',R.Name);
|
|
AssertEquals('function argument count',0,A.aFunction.TypedParams.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrowFunctionTwoArgs;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrowFunctionTypeDef;
|
|
P : TJSTypedParam;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('type CallBack = (data : t, context: t2) => void;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','CallBack',T.Name);
|
|
A:=TJSArrowFunctionTypeDef(CheckClass(T.TypeDef,TJSArrowFunctionTypeDef,'Have arrow function'));
|
|
AssertNotNull('Have function definition',A.aFunction);
|
|
R:=TJSTypeReference(CheckClass(A.aFunction.ResultType,TJSTypeReference,'Have function result'));
|
|
AssertEquals('result type name','void',R.Name);
|
|
AssertEquals('function argument count',2,A.aFunction.TypedParams.Count);
|
|
P:=A.aFunction.TypedParams.Params[0];
|
|
AssertEquals('param name','data',P.Name);
|
|
R:=TJSTypeReference(CheckClass(P.Node,TJSTypeReference,'Have param 0 type'));
|
|
AssertEquals('param type name','t',R.Name);
|
|
P:=A.aFunction.TypedParams.Params[1];
|
|
AssertEquals('param name','context',P.Name);
|
|
R:=TJSTypeReference(CheckClass(P.Node,TJSTypeReference,'Have param 1 type'));
|
|
AssertEquals('param type name','t2',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeArrowFunctionArgsCommaEnd;
|
|
Var
|
|
T : TJSTypeDeclaration;
|
|
A : TJSArrowFunctionTypeDef;
|
|
P : TJSTypedParam;
|
|
R : TJSTypeReference;
|
|
begin
|
|
StartTS('type CallBack = ( '#10+
|
|
' reject: FN,'#10+
|
|
') => void;');
|
|
T:=GetFirstType;
|
|
AssertEquals('Name','CallBack',T.Name);
|
|
A:=TJSArrowFunctionTypeDef(CheckClass(T.TypeDef,TJSArrowFunctionTypeDef,'Have arrow function'));
|
|
AssertNotNull('Have function definition',A.aFunction);
|
|
R:=TJSTypeReference(CheckClass(A.aFunction.ResultType,TJSTypeReference,'Have function result'));
|
|
AssertEquals('result type name','void',R.Name);
|
|
AssertEquals('function argument count',1,A.aFunction.TypedParams.Count);
|
|
P:=A.aFunction.TypedParams.Params[0];
|
|
AssertEquals('param name','reject',P.Name);
|
|
R:=TJSTypeReference(CheckClass(P.Node,TJSTypeReference,'Have param 0 type'));
|
|
AssertEquals('param type name','FN',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeObjectPropRef;
|
|
|
|
Var
|
|
aDecl : TJSTypeDeclaration;
|
|
ObjType : TJSObjectTypeDef;
|
|
PropType : TJSPropertyDeclaration;
|
|
U : TJSUnionTypeDef;
|
|
A : TJSArrayTypeDef;
|
|
F : TJSFixedValueReference;
|
|
|
|
begin
|
|
// rimraf.Options &
|
|
StartTs('type Options = {'#10 +
|
|
' glob?: rimraf.Options["glob"] | true;'#10 +
|
|
' disableGlob?: never;'#10 +
|
|
' };');
|
|
aDecl:=TJSTypeDeclaration(CheckClass('First type',TJSTypeDeclaration,GetFirstType));
|
|
ObjType:=TJSObjectTypeDef(CheckClass('a type',TJSObjectTypeDef,aDecl.TypeDef));
|
|
PropType:=TJSPropertyDeclaration(CheckClass('First prop',TJSPropertyDeclaration,ObjType.Elements[0]));
|
|
U:=TJSUnionTypeDef(CheckClass('Prop type',TJSUnionTypeDef,PropType.ElementType));
|
|
A:=TJSArrayTypeDef(CheckClass('First el',TJSArrayTypeDef,U.Types[0]));
|
|
F:=TJSFixedValueReference(CheckClass('Array Index',TJSFixedValueReference,A.IndexType));
|
|
AssertEquals('value','glob',F.FixedValue.Value.AsString);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareEnum;
|
|
|
|
Var
|
|
E : TJSEnumDeclaration;
|
|
ET : TJSEnumTypeDef;
|
|
|
|
begin
|
|
StartTS('enum Colors {red,blue,green};');
|
|
E:=GetFirstEnum;
|
|
AssertEquals('Name','Colors',E.Name);
|
|
ET:=TJSEnumTypeDef(CheckClass(E.EnumDef,TJSEnumTypeDef,'Have enum definition'));
|
|
AssertEquals('Member count',3,ET.NameCount);
|
|
AssertEquals('Member 0','red',ET.Names[0]);
|
|
AssertEquals('Member 1','blue',ET.Names[1]);
|
|
AssertEquals('Member 2','green',ET.Names[2]);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareEnumKeywordElement;
|
|
Var
|
|
E : TJSEnumDeclaration;
|
|
ET : TJSEnumTypeDef;
|
|
|
|
begin
|
|
StartTS('enum Colors {delete,new,green};');
|
|
E:=GetFirstEnum;
|
|
AssertEquals('Name','Colors',E.Name);
|
|
ET:=TJSEnumTypeDef(CheckClass(E.EnumDef,TJSEnumTypeDef,'Have enum definition'));
|
|
AssertEquals('Member count',3,ET.NameCount);
|
|
AssertEquals('Member 0','delete',ET.Names[0]);
|
|
AssertEquals('Member 1','new',ET.Names[1]);
|
|
AssertEquals('Member 2','green',ET.Names[2]);
|
|
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareConstEnum;
|
|
Var
|
|
Stat : TJSEnumStatement;
|
|
E : TJSEnumDeclaration;
|
|
ET : TJSEnumTypeDef;
|
|
|
|
begin
|
|
StartTS('const enum Colors {red,blue,green};');
|
|
Stat:=TJSEnumStatement(CheckClass('First statement',TJSEnumStatement,GetFirstStatement));
|
|
E:=TJSEnumDeclaration(CheckClass('Decl',TJSEnumDeclaration,Stat.EnumDecl));
|
|
AssertEquals('Name','Colors',E.Name);
|
|
ET:=TJSEnumTypeDef(CheckClass(E.EnumDef,TJSEnumTypeDef,'Have enum definition'));
|
|
AssertEquals('Is const',True,ET.IsConst);
|
|
AssertEquals('Member count',3,ET.NameCount);
|
|
AssertEquals('Member 0','red',ET.Names[0]);
|
|
AssertEquals('Member 1','blue',ET.Names[1]);
|
|
AssertEquals('Member 2','green',ET.Names[2]);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareConstEnumAssigned;
|
|
Var
|
|
Stat : TJSEnumStatement;
|
|
E : TJSEnumDeclaration;
|
|
ET : TJSEnumTypeDef;
|
|
Lit : TJSLiteral;
|
|
|
|
begin
|
|
StartTS('const enum Colors {red = 1,blue = 2,green};');
|
|
Stat:=TJSEnumStatement(CheckClass('First statement',TJSEnumStatement,GetFirstStatement));
|
|
E:=TJSEnumDeclaration(CheckClass('Decl',TJSEnumDeclaration,Stat.EnumDecl));
|
|
AssertEquals('Name','Colors',E.Name);
|
|
ET:=TJSEnumTypeDef(CheckClass(E.EnumDef,TJSEnumTypeDef,'Have enum definition'));
|
|
AssertEquals('Is const',True,ET.IsConst);
|
|
AssertEquals('Member count',3,ET.NameCount);
|
|
AssertEquals('Member 0','red',ET.Names[0]);
|
|
lit:=TJSLiteral(CheckClass('Member 0 assigned',TJSLiteral,ET.Elements[0].Value));
|
|
AssertEquals('Lit value',1,Lit.Value.AsNumber);
|
|
AssertEquals('Member 1','blue',ET.Names[1]);
|
|
lit:=TJSLiteral(CheckClass('Member 1 assigned',TJSLiteral,ET.Elements[1].Value));
|
|
AssertEquals('Lit value',2,Lit.Value.AsNumber);
|
|
AssertEquals('Member 2','green',ET.Names[2]);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceEmpty;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
|
|
begin
|
|
StartTS('interface Empty {};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Empty',Decl.Name);
|
|
AssertNull('No Extends',Decl.Extends);
|
|
// AssertEquals('Extends count',0,Decl.Extends.Count);
|
|
AssertEquals('Members count',0,Decl.Values.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareAmbientInterfaceEmpty;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
|
|
begin
|
|
StartTS('declare interface Empty {};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertEquals('First type node is type declaration',True,GetInterfaces.Nodes[0].IsAmbient);
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Empty',Decl.Name);
|
|
AssertNull('No Extends',Decl.Extends);
|
|
// AssertEquals('Extends count',0,Decl.Extends.Count);
|
|
AssertEquals('Members count',0,Decl.Values.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceExtendsEmpty;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Lit : TJSLiteral;
|
|
|
|
begin
|
|
StartTS('interface Empty extends ParentEmpty {};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Empty',Decl.Name);
|
|
AssertNotNull('Extends',Decl.Extends);
|
|
AssertEquals('Extends count',1,Decl.Extends.Count);
|
|
Lit:=TJSLiteral(CheckClass(Decl.Extends.Nodes[0].Node,TJSLiteral,'Literal 0 '));
|
|
AssertNotNull('Lit has value',Lit.Value);
|
|
AssertEquals('Extends name','ParentEmpty',Lit.Value.AsString);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceExtendsTwoEmpty;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Lit : TJSLiteral;
|
|
|
|
begin
|
|
StartTS('interface Empty extends ParentEmpty,MoreEmpty {};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Empty',Decl.Name);
|
|
AssertNotNull('Extends',Decl.Extends);
|
|
AssertEquals('Extends count',2,Decl.Extends.Count);
|
|
Lit:=TJSLiteral(CheckClass(Decl.Extends.Nodes[0].Node,TJSLiteral,'Literal 0 '));
|
|
AssertNotNull('Lit has value',Lit.Value);
|
|
AssertEquals('Extends name','ParentEmpty',Lit.Value.AsString);
|
|
Lit:=TJSLiteral(CheckClass(Decl.Extends.Nodes[1].Node,TJSLiteral,'Literal 0 '));
|
|
AssertNotNull('Lit has value',Lit.Value);
|
|
AssertEquals('Extends name','MoreEmpty',Lit.Value.AsString);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceProperty;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface Friend { name: string; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Friend',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Property class',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Property name','name',Prop.Name);
|
|
AssertEquals('Property optional',koDefault,Prop.Optional);
|
|
R:=TJSTypeReference(CheckClass('Property type',TJSTypeReference,Prop.ElementType));
|
|
AssertEquals('Property type name','string',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceOptionalProperty;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface Friend { name ? : string; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Friend',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Property class',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Property name','name',Prop.Name);
|
|
AssertEquals('Property optional',koOptional,Prop.Optional);
|
|
R:=TJSTypeReference(CheckClass('Property type',TJSTypeReference,Prop.ElementType));
|
|
AssertEquals('Property type name','string',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceUntypedProperty;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface Friend { name ; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Friend',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Property class',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Property name','name',Prop.Name);
|
|
AssertEquals('Property optional',koDefault,Prop.Optional);
|
|
R:=TJSTypeReference(CheckClass('Property type',TJSTypeReference,Prop.ElementType));
|
|
AssertEquals('Property type name','any',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceOptionalUntypedProperty;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface Friend { name ? ; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Friend',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Property class',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Property name','name',Prop.Name);
|
|
AssertEquals('Property optional',koOptional,Prop.Optional);
|
|
R:=TJSTypeReference(CheckClass('Property type',TJSTypeReference,Prop.ElementType));
|
|
AssertEquals('Property type name','any',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceMethod;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
M : TJSMethodDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface JQuery { text (content: string) : string; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
M:=TJSMethodDeclaration(CheckClass('Method class',TJSMethodDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Method name','text',M.Name);
|
|
AssertEquals('Method optional',koDefault,M.Optional);
|
|
AssertNotNull('Have function def',M.FuncDef);
|
|
R:=TJSTypeReference(CheckClass('Result type',TJSTypeReference,M.FuncDef.ResultType));
|
|
AssertEquals('Property type name','string',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceMethodNoReturn;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
M : TJSMethodDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface JQuery { text (content: string) ; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
M:=TJSMethodDeclaration(CheckClass('Method class',TJSMethodDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Method name','text',M.Name);
|
|
AssertEquals('Method optional',koDefault,M.Optional);
|
|
AssertNotNull('Have function def',M.FuncDef);
|
|
R:=TJSTypeReference(CheckClass('Result type',TJSTypeReference,M.FuncDef.ResultType));
|
|
AssertEquals('Property type name','any',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceCallable;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
M : TJSMethodDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface JQuery { (query : string) : JQuery; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
M:=TJSMethodDeclaration(CheckClass('Method class',TJSMethodDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Method name','',M.Name);
|
|
AssertEquals('Method optional',koDefault,M.Optional);
|
|
AssertNotNull('Have function def',M.FuncDef);
|
|
R:=TJSTypeReference(CheckClass('Result type',TJSTypeReference,M.FuncDef.ResultType));
|
|
AssertEquals('Property type name','JQuery',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceMethodThisReturn;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
M : TJSMethodDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface JQuery { text (content: string) : this; };');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertEquals('Member count',1,Decl.ElementCount);
|
|
M:=TJSMethodDeclaration(CheckClass('Method class',TJSMethodDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Method name','text',M.Name);
|
|
AssertEquals('Method optional',koDefault,M.Optional);
|
|
AssertNotNull('Have function def',M.FuncDef);
|
|
R:=TJSTypeReference(CheckClass('Result type',TJSTypeReference,M.FuncDef.ResultType));
|
|
AssertEquals('Property type name','this',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclateInterfaceGenericProperty;
|
|
|
|
Var
|
|
Decl:TJSInterfaceDeclaration;
|
|
Prop: TJSPropertyDeclaration;
|
|
R: TJSTypeReference;
|
|
U : TJSUnionTypeDef;
|
|
G : TJSGenericTypeRef;
|
|
|
|
begin
|
|
STartTS('export interface CalendarBaseProps { '+
|
|
' dayComponent?: React.Component<DayComponentProps> | React.SFC<DayComponentProps>; '+
|
|
' disabledByDefault?: boolean;'+
|
|
'};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertEquals('Count elements',2,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Property class',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('Property name','dayComponent',Prop.Name);
|
|
AssertEquals('Property optional',koOptional,Prop.Optional);
|
|
U:=TJSUnionTypeDef(CheckClass('Property type',TJSUnionTypeDef,Prop.ElementType));
|
|
G:=TJSGenericTypeRef(CheckClass('Union 1',TJSGenericTypeRef,U.Types[0]));
|
|
R:=TJSTypeReference(CheckClass('Generic base type',TJSTypeReference,G.BaseType));
|
|
AssertEquals('Generic 1 base type Name ','React.Component',R.Name);
|
|
G:=TJSGenericTypeRef(CheckClass('Union 2',TJSGenericTypeRef,U.Types[1]));
|
|
R:=TJSTypeReference(CheckClass('Generic base type',TJSTypeReference,G.BaseType));
|
|
AssertEquals('Generic 2 base type Name ','React.SFC',R.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclateInterfaceGeneric;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
R : TJSTypeReference;
|
|
Lit : TJSLiteral;
|
|
|
|
begin
|
|
StartTS('interface Empty <TItem> extends ParentEmpty {};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','Empty',Decl.Name);
|
|
AssertNotNull('Extends',Decl.Extends);
|
|
AssertEquals('Type param count',1,Decl.TypeParams.Count);
|
|
R:=TJSTypeReference(CheckClass('Type param 1',TJSTypeReference,Decl.TypeParams.Nodes[0].Node));
|
|
AssertEquals('Type param Name','TItem',R.Name);
|
|
AssertEquals('Extends count',1,Decl.Extends.Count);
|
|
Lit:=TJSLiteral(CheckClass(Decl.Extends.Nodes[0].Node,TJSLiteral,'Literal 0 '));
|
|
AssertNotNull('Lit has value',Lit.Value);
|
|
AssertEquals('Extends name','ParentEmpty',Lit.Value.AsString);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceExtendsGeneric;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('interface Empty <TItem> extends ParentEmpty<Titem> {};');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration',Decl);
|
|
AssertEquals('Name','Empty',Decl.Name);
|
|
AssertNotNull('Extends',Decl.Extends);
|
|
AssertEquals('Type param count',1,Decl.TypeParams.Count);
|
|
R:=TJSTypeReference(CheckClass('Type param 1',TJSTypeReference,Decl.TypeParams.Nodes[0].Node));
|
|
AssertEquals('Type param Name','TItem',R.Name);
|
|
AssertEquals('Extends count',1,Decl.Extends.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceHidden;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
begin
|
|
StartTS('interface JQuery extends JQuerySlickInitials {'#10+
|
|
' hidden: ''mozHidden'' | ''webkitHidden'' | ''hidden'';'#10+
|
|
'}');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass(GetFirstInterface,TJSInterfaceDeclaration,'Interface'));
|
|
AssertNotNull('Have declaration',Decl);
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNotNull('Extends',Decl.Extends);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassEmpty;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
|
|
begin
|
|
StartTS('declare class JQuery {};');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertNull('Members',Decl.Members);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareAbstractClassEmpty;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
|
|
begin
|
|
StartTS('declare abstract class JQuery {};');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertNull('Members',Decl.Members);
|
|
AssertTrue('Abstract',Decl.IsAbstract);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassIndexSignature;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
SigDecl : TJSIndexSignatureDeclaration;
|
|
|
|
begin
|
|
StartTS('class TDictionary { [a : string] : string; } ;');
|
|
Decl:=TJSClassDeclaration(CheckClass('Interface',TJSClassDeclaration,GetFirstClass));
|
|
AssertEquals('Interface name','TDictionary',Decl.Name);
|
|
AssertEquals('One var',1,Decl.Members.Vars.Count);
|
|
SigDecl:=TJSIndexSignatureDeclaration(CheckClass('Index signature',TJSIndexSignatureDeclaration,Decl.Members.Vars[0].Node));
|
|
AssertEquals('No name','',SigDecl.Name);
|
|
AssertEquals('Index type','string',SigDecl.IndexType);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassIndexSignatureIn;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
SigDecl : TJSIndexSignatureDeclaration;
|
|
IndexType : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('class TDictionary { [a in B] : string; } ;');
|
|
Decl:=TJSClassDeclaration(CheckClass('Interface',TJSClassDeclaration,GetFirstClass));
|
|
AssertEquals('Interface name','TDictionary',Decl.Name);
|
|
AssertEquals('One var',1,Decl.Members.Vars.Count);
|
|
SigDecl:=TJSIndexSignatureDeclaration(CheckClass('Index signature',TJSIndexSignatureDeclaration,Decl.Members.Vars[0].Node));
|
|
AssertEquals('No name','',SigDecl.Name);
|
|
IndexType:=TJSTypeReference(CheckClass('Index type',TJSTypeReference,SigDecl.InIndexType));
|
|
AssertEquals('Type ref name','B',IndexType.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassExtendsGeneric;
|
|
Var
|
|
Decl : TJSAmbientClassDeclaration;
|
|
Gen : TJSGenericTypeRef;
|
|
Ref : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('declare class JQuery extends MyClass<any> {};');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
Gen:=TJSGenericTypeRef(CheckClass('Extends class',TJSGenericTypeRef,Decl.Extends));
|
|
Ref:=TJSTypeReference(CheckClass('Base class',TJSTypeReference,Gen.BaseType));
|
|
AssertEquals('Name','MyClass',Ref.Name);
|
|
AssertNull('Members',Decl.Members);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassGeneric;
|
|
Var
|
|
Decl : TJSAmbientClassDeclaration;
|
|
Ref : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('declare class JQuery<any> extends MyClass {};');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
Ref:=TJSTypeReference(CheckClass('Base class',TJSTypeReference,Decl.extends));
|
|
AssertEquals('Name','MyClass',Ref.Name);
|
|
AssertNotNull('Have type params',Decl.TypeParams);
|
|
AssertEquals('Type Param count ',1,Decl.TypeParams.Count);
|
|
Ref:=TJSTypeReference(CheckClass('Base class',TJSTypeReference,Decl.TypeParams.Nodes[0].Node));
|
|
AssertEquals('Name','any',Ref.Name);
|
|
AssertNull('Members',Decl.Members);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassStaticFunction;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
begin
|
|
StartTS('declare class JQuery { static extends() : string; };');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertEquals('Function count',1,Decl.Members.Functions.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassStaticFunctionUntypedArg;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
begin
|
|
StartTS('declare class JQuery { private soso(a) ; };');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertEquals('Function count',1,Decl.Members.Functions.Count);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassStaticReadonlyProperty;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
|
|
begin
|
|
StartTS('declare class JQuery { static readonly a : string; };');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertEquals('Var count',1,Decl.Members.vars.Count);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Class',TJSPropertyDeclaration,Decl.Members.vars.JSElements[0]));
|
|
AssertTrue('Prop readonly',Prop.IsReadOnly);
|
|
AssertTrue('Prop Static',Prop.IsStatic);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassReadonlyProperty;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
begin
|
|
StartTS('declare class JQuery { readonly a : string; };');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertEquals('Var count',1,Decl.Members.vars.Count);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Class',TJSPropertyDeclaration,Decl.Members.vars.JSElements[0]));
|
|
AssertTrue('Prop readonly',Prop.IsReadOnly);
|
|
AssertFalse('Prop Static',Prop.IsStatic);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassGenericFunctionProperty;
|
|
begin
|
|
StartTS('declare class changeRequestInterceptor {'#10+
|
|
' getRequest: <T>(request: T, entity: Entity, index: number) => T;'#10+
|
|
'}');
|
|
GetFirstClass(True);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassImplements;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
begin
|
|
StartTS('declare class JQuery implements IQuery { readonly a : string; };');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertEquals('Var count',1,Decl.Members.vars.Count);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Class',TJSPropertyDeclaration,Decl.Members.vars.JSElements[0]));
|
|
AssertTrue('Prop readonly',Prop.IsReadOnly);
|
|
AssertFalse('Prop Static',Prop.IsStatic);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassExtendsFunctionCall;
|
|
|
|
Var
|
|
Decl: TJSAmbientClassDeclaration;
|
|
E : TJSTypeFuncCall;
|
|
|
|
begin
|
|
StartTS('declare class TextArea extends Component.extend(TextSupport) {}');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration',Decl);
|
|
AssertEquals('Name','TextArea',Decl.Name);
|
|
E:=TJSTypeFuncCall(CheckClass('Extends',TJSTypeFuncCall,Decl.Extends));
|
|
AssertEquals('Function name','Component.extend',E.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareClassStaticReadOnly;
|
|
|
|
Var
|
|
Decl: TJSAmbientClassDeclaration;
|
|
E : TJSClassConstDeclaration;
|
|
|
|
begin
|
|
StartTS('declare class A { static readonly B = 1 }');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration',Decl);
|
|
AssertEquals('Name','A',Decl.Name);
|
|
AssertEquals('member count',1,Decl.ClassDef.ElementCount);
|
|
AssertEquals('Member name','B',Decl.ClassDef.Elements[0].Name);
|
|
E:=TJSClassConstDeclaration(CheckClass('Member class',TJSClassConstDeclaration,Decl.ClassDef.Elements[0]));
|
|
AssertNotNull(E);
|
|
end;
|
|
|
|
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceIndexSignature;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
SigDecl : TJSIndexSignatureDeclaration;
|
|
|
|
begin
|
|
StartTS('interface TDictionary { [a : string] : string; } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','TDictionary',Decl.Name);
|
|
AssertEquals('One var',1,Decl.ElementCount);
|
|
SigDecl:=TJSIndexSignatureDeclaration(CheckClass('Index signature',TJSIndexSignatureDeclaration,Decl.Elements[0]));
|
|
AssertEquals('No name','',SigDecl.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceFixedStringProperty;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
begin
|
|
StartTS('export interface Color { R : "red" } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
AssertEquals('One member',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Element 0',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('member name','R',Prop.Name);
|
|
AssertEquals('member fixed value','red',Prop.FixedStringValue);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceFixedBooleanProperty;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
Fix : TJSFixedValueReference;
|
|
|
|
begin
|
|
StartTS('export interface Color { R : false } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
AssertEquals('One member',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Element 0',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('member name','R',Prop.Name);
|
|
Fix:=TJSFixedValueReference(CheckClass('member fixed value',TJSFixedValueReference,Prop.ElementType));
|
|
AssertNotNull('Value literal',Fix.FixedValue);
|
|
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceFixedUnionProperty;
|
|
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
Prop : TJSPropertyDeclaration;
|
|
U : TJSUnionTypeDef;
|
|
Fix : TJSFixedValueReference;
|
|
|
|
begin
|
|
StartTS('export interface Color { R : false | ''string'' } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
AssertEquals('One member',1,Decl.ElementCount);
|
|
Prop:=TJSPropertyDeclaration(CheckClass('Element 0',TJSPropertyDeclaration,Decl.Elements[0]));
|
|
AssertEquals('member name','R',Prop.Name);
|
|
U:=TJSUnionTypeDef(CheckClass('member fixed value',TJSUnionTypeDef,Prop.ElementType));
|
|
AssertEquals('Member count',2,U.TypeCount);
|
|
Fix:=TJSFixedValueReference(CheckClass('member fixed value',TJSFixedValueReference,U.Types[0]));
|
|
AssertNotNull('Value literal',Fix.FixedValue);
|
|
Fix:=TJSFixedValueReference(CheckClass('member fixed value',TJSFixedValueReference,U.Types[1]));
|
|
AssertNotNull('Value literal',Fix.FixedValue);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceDestructuredFunctionProperty;
|
|
begin
|
|
StartTs('interface I18nComponentProps {'#10+
|
|
' children: ({ i18n, i18nHash }: { i18n: I18n, i18nHash?: string }) => ReactNode;'#10+
|
|
'}');
|
|
AssertNotNull(GetFirstStatement);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareExportInterfaceDestructuredFunctionProperty;
|
|
begin
|
|
StartTs('export interface I18nComponentProps {'#10+
|
|
' children: ({ i18n, i18nHash }: { i18n: I18n, i18nHash?: string }) => ReactNode;'#10+
|
|
'}');
|
|
AssertNotNull(GetFirstStatement);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareInterfaceNoSemicolon;
|
|
begin
|
|
StartTs(' interface Conversions {'#10+
|
|
' ansi: (ansi: number) => string'#10+
|
|
' rgb: (r: number, g: number, b: number) => string'#10+
|
|
'}');
|
|
AssertNotNull(GetFirstStatement);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareConstructorSignature;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
meth : TJSMethodDeclaration;
|
|
begin
|
|
StartTS('export interface Color { new (r: number, g:number, b : number) : Color; } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
AssertEquals('One member',1,Decl.ElementCount);
|
|
Meth:=TJSMethodDeclaration(CheckClass('Element 0',TJSMethodDeclaration,Decl.Elements[0]));
|
|
AssertEquals('member name','new',Meth.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunctionDestructuredParam;
|
|
begin
|
|
StartTS('declare function A({b,c,d} : E): F;');
|
|
GetStatements;
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunctionIs;
|
|
begin
|
|
StartTS('declare function hasOwnProperty(target: A): target is B ;');
|
|
GetStatements;
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareFunctionThisParam;
|
|
begin
|
|
StartTS('declare function hasOwnProperty(this: A): B ;');
|
|
GetStatements;
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeGenericConstraint;
|
|
|
|
Var
|
|
Decl : TJSTypeDeclaration;
|
|
|
|
begin
|
|
StartTs('type ValueMap<T extends BaseType, Datum> = { [key: string]: number | string | boolean | null | ValueFn<T, Datum, number | string | boolean | null> };');
|
|
Decl:=GetFirstType;
|
|
AssertNotNull(Decl);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeTypeImport;
|
|
|
|
Var
|
|
Decl : TJSImportTypeRef;
|
|
|
|
begin
|
|
StartTS(' type AppChannel = import(''main'').AppChannel;');
|
|
Decl:=TJSImportTypeRef(CheckClass('First',TJSImportTypeRef,GetFirstType.TypeDef));
|
|
AssertEquals('Name','AppChannel',Decl.Name);
|
|
AssertEquals('File','main',Decl.fileName);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeTypeOfImport;
|
|
|
|
Var
|
|
Decl : TJSImportTypeRef;
|
|
|
|
begin
|
|
StartTS(' type AppChannel = typeof import(''main'').AppChannel;');
|
|
Decl:=TJSImportTypeRef(CheckClass('First',TJSImportTypeRef,GetFirstType.TypeDef));
|
|
AssertEquals('Name','AppChannel',Decl.Name);
|
|
AssertEquals('File','main',Decl.fileName);
|
|
AssertEquals('File',True,Decl.IsTypeOf);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeTypeOfDefault;
|
|
Var
|
|
Decl : TJSImportTypeRef;
|
|
|
|
begin
|
|
StartTS(' type AppChannel = typeof import(''main'').default;');
|
|
Decl:=TJSImportTypeRef(CheckClass('First',TJSImportTypeRef,GetFirstType.TypeDef));
|
|
AssertEquals('Name','default',Decl.Name);
|
|
AssertEquals('File','main',Decl.fileName);
|
|
AssertEquals('File',True,Decl.IsTypeOf);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareTypeReadonly;
|
|
Var
|
|
Decl : TJSFunctionStatement;
|
|
Def : TJSFuncDef;
|
|
R : TJSTypeReference;
|
|
|
|
begin
|
|
StartTS('declare function markdownTable(table: readonly string): string;');
|
|
Decl:=GetFirstFunction;
|
|
AssertNotNull('Have decl',Decl.AFunction);
|
|
Def:=Decl.AFunction;
|
|
AssertEquals('Params',1,Def.TypedParams.Count);
|
|
R:=TJSTypeReference(CheckClass('Arg type',TJSTypeReference,Def.TypedParams.Types[0]));
|
|
AssertTrue('Read only',R.IsReadonly);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestDeclareArgTypeInferred;
|
|
Var
|
|
Decl : TJSTypeDeclaration;
|
|
begin
|
|
StartTS('type A = (args: infer B) => C;');
|
|
Decl:=GetFirstType;
|
|
AssertNotNull(Decl);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportNamespacedClass;
|
|
|
|
Var
|
|
NS : TJSNamespaceDeclaration;
|
|
Exp : TJSExportStatement;
|
|
|
|
begin
|
|
StartTS('export namespace Collection {'#10+
|
|
' type EventType = string;'#10+
|
|
' class Event extends events.Event {'#10+
|
|
' constructor(type: EventType, opt_element?: any);'#10+
|
|
' element: any;'#10+
|
|
' }'#10+
|
|
'}');
|
|
Exp:=TJSExportStatement(CheckClass('Export',TJSExportStatement,GetFirstStatement));
|
|
NS:=TJSNamespaceDeclaration(CheckClass('Namespace', TJSNamespaceDeclaration, Exp.Declaration));
|
|
AssertEquals('NS name','Collection',NS.Name);
|
|
end;
|
|
|
|
|
|
procedure TTestTypeScriptParser.TestExportClassConstructor;
|
|
Var
|
|
Decl : TJSClassDeclaration;
|
|
|
|
begin
|
|
StartTS('export class JQuery { constructor (); };');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertNotNull('Members',Decl.Members);
|
|
AssertEquals('members count',1,Decl.Members.Functions.Count);
|
|
AssertFalse('Abstract',Decl.IsAbstract);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportAbstractClass;
|
|
Var
|
|
Decl : TJSAmbientClassDeclaration;
|
|
|
|
begin
|
|
StartTS('export abstract class JQuery {};');
|
|
Decl:=TJSAmbientClassDeclaration(CheckClass('Class',TJSAmbientClassDeclaration,GetFirstClass(True)));
|
|
AssertNotNull('Have declaration');
|
|
AssertEquals('Name','JQuery',Decl.Name);
|
|
AssertNull('Extends',Decl.Extends);
|
|
AssertNull('Members',Decl.Members);
|
|
AssertTrue('Abstract',Decl.IsAbstract);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportInterface;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
begin
|
|
StartTS('export interface Color { R,G,B : string; } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportInterfaceDefault;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
begin
|
|
StartTS('export default interface Color { R,G,B : string; } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportInterfaceIndexSignature;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
SigDecl : TJSIndexSignatureDeclaration;
|
|
begin
|
|
StartTS('export interface Color { level : string; [key : string] : any; } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
AssertEquals('One var',2,Decl.ElementCount);
|
|
SigDecl:=TJSIndexSignatureDeclaration(CheckClass('Index signature',TJSIndexSignatureDeclaration,Decl.Elements[1]));
|
|
AssertEquals('No name','',SigDecl.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportInterfaceIndexSignatureOptional;
|
|
Var
|
|
Decl : TJSInterfaceDeclaration;
|
|
SigDecl : TJSIndexSignatureDeclaration;
|
|
begin
|
|
StartTS('export interface Color { [key : string] ? : any; } ;');
|
|
Decl:=TJSInterfaceDeclaration(CheckClass('Interface',TJSInterfaceDeclaration,GetFirstInterface));
|
|
AssertEquals('Interface name','Color',Decl.Name);
|
|
AssertEquals('One var',1,Decl.ElementCount);
|
|
SigDecl:=TJSIndexSignatureDeclaration(CheckClass('Index signature',TJSIndexSignatureDeclaration,Decl.Elements[0]));
|
|
AssertEquals('No name','',SigDecl.Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportImportStatement;
|
|
|
|
Var
|
|
expDecl : TJSExportStatement;
|
|
Decl : TJSImportStatement;
|
|
Call : TJSCallExpression;
|
|
|
|
begin
|
|
StartTS('export import LocaleConfig = require("locale");');
|
|
ExpDecl:=TJSExportStatement(CheckClass('import',TJSExportStatement,GetFirstStatement));
|
|
Decl:=TJSImportStatement(CheckClass('import',TJSImportStatement,expDecl.Declaration));
|
|
Call:=TJSCallExpression(CheckClass('Have import assign', TJSCallExpression, Decl.Expression));
|
|
AssertNotNull('Have call expression',Call.Expr);
|
|
CheckClass('Call function name',TJSPrimaryExpressionIdent,Call.Expr);
|
|
AssertEquals('call function','require',TJSPrimaryExpressionIdent(Call.Expr).Name);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportAssignStatement;
|
|
|
|
var
|
|
Decl: TJSExportStatement;
|
|
|
|
begin
|
|
StartTS('export = LocaleConfig;');
|
|
Decl:=TJSExportStatement(CheckClass('export',TJSExportStatement,GetFirstStatement));
|
|
AssertNotNull('Have assignment',Decl.Declaration);
|
|
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportAsNamespace;
|
|
var
|
|
Decl: TJSExportStatement;
|
|
|
|
begin
|
|
StartTS('export as namespace B;');
|
|
Decl:=TJSExportStatement(CheckClass('export',TJSExportStatement,GetFirstStatement));
|
|
AssertEquals('Namespace export','B',Decl.NameSpaceExport);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportNamespaceClass;
|
|
|
|
var
|
|
Decl: TJSNamespaceDeclaration;
|
|
|
|
begin
|
|
StartTS('declare namespace g { export class Grid { collection(name?: string): mongo.Collection; } };');
|
|
Decl:=TJSNamespaceDeclaration(CheckClass('export',TJSNamespaceDeclaration,GetFirstNameSpace));
|
|
AssertNotNull('Have namespace',Decl);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportFunction;
|
|
|
|
Var
|
|
Exp : TJSExportStatement;
|
|
|
|
begin
|
|
StartTs('export function clone(stylesheet: CSSStyleSheet): CSSStyleSheet;'#10+
|
|
'export function parse(token: string): CSSStyleSheet;');
|
|
AssertEquals('Statement count',2,GetStatements.Count);
|
|
Exp:=TJSExportStatement(CheckClass('export',TJSExportStatement,GetFirstStatement));
|
|
AssertNotNull('Have statement',Exp);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportDefaultFunction;
|
|
|
|
Var
|
|
Exp : TJSExportStatement;
|
|
|
|
begin
|
|
StartTs('export default function (stylesheet: CSSStyleSheet): CSSStyleSheet;');
|
|
AssertEquals('Statement count',1,GetStatements.Count);
|
|
Exp:=TJSExportStatement(CheckClass('export',TJSExportStatement,GetFirstStatement));
|
|
AssertNotNull('Have statement',Exp);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportTypeArrowFunctionArgsComma;
|
|
Var
|
|
S : TJSExportStatement;
|
|
|
|
begin
|
|
StartTS('export type ConnectionRequestCb = ('#10+
|
|
' info: ConnectionRequestInfo,'#10+
|
|
' accept: ConnectionRequestAcceptFn,'#10+
|
|
' reject: ConnectionRequestRejectFn,'#10+
|
|
' ) => void;');
|
|
S:=TJSExportStatement(CheckClass('First statement',TJSExportStatement,GetFirstStatement));
|
|
CheckClass('Decl',TJSTypeDeclaration,S.Declaration);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportEnum;
|
|
Var
|
|
S : TJSExportStatement;
|
|
E : TJSEnumDeclaration;
|
|
ET : TJSEnumTypeDef;
|
|
|
|
begin
|
|
StartTS('export enum Colors {red,blue,green};');
|
|
S:=TJSExportStatement(CheckClass('First statement',TJSExportStatement,GetFirstStatement));
|
|
E:=TJSEnumDeclaration(CheckClass('Decl',TJSEnumDeclaration,S.Declaration));
|
|
AssertEquals('Name','Colors',E.Name);
|
|
ET:=TJSEnumTypeDef(CheckClass(E.EnumDef,TJSEnumTypeDef,'Have enum definition'));
|
|
AssertEquals('Member count',3,ET.NameCount);
|
|
AssertEquals('Member 0','red',ET.Names[0]);
|
|
AssertEquals('Member 1','blue',ET.Names[1]);
|
|
AssertEquals('Member 2','green',ET.Names[2]);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportObjectUnion;
|
|
|
|
begin
|
|
StartTs('export type VisitorIdentifier = { id: string } | { user_id: string };'#10+
|
|
'export interface Visitor {'#10+
|
|
' type: "visitor"; '#10+
|
|
'}');
|
|
AssertNotNull(GetStatements);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportNoSemicolon;
|
|
begin
|
|
StartTs('export function intlReducer(state: IntlState | undefined, action: IntlAction): IntlState'#10+
|
|
'export function updateIntl (opts: IntlState): IntlAction');
|
|
AssertNotNull(GetStatements);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestExportAsKeyWord;
|
|
begin
|
|
StartTs('export { del as delete };');
|
|
AssertNotNull(GetStatements);
|
|
end;
|
|
|
|
procedure TTestTypeScriptParser.TestNamespaceInterfaceFunction;
|
|
|
|
Var
|
|
NS : TJSNameSpaceStatement;
|
|
|
|
begin
|
|
StartTs('declare namespace Rox {'#10+
|
|
' interface RoxContainer {'#10+
|
|
' [key: string]: Flag | RoxNumber | RoxString;'#10+
|
|
' }'#10+
|
|
' function register(namespace: string, roxContainer: RoxContainer): void;'#10+
|
|
' function register(roxContainer: RoxContainer): void;'#10+
|
|
'}');
|
|
NS:=TJSNameSpaceStatement(CheckClass('NS',TJSNameSpaceStatement,GetFirstStatement));
|
|
AssertNotNull(NS);
|
|
end;
|
|
|
|
initialization
|
|
RegisterTest(TTestTypeScriptParser);
|
|
end.
|
|
|