Lines Matching full:compiler

28 import { Compiler } from "../compiler";
47 export function compileClassDeclaration(compiler: Compiler, stmt: ts.ClassLikeDeclaration) {
48     compiler.pushScope(stmt);
50     let pandaGen = compiler.getPandaGen();
58     let baseVreg = compileHeritageClause(compiler, stmt);
71             compiler.compileExpression(<ts.Expression>prop.getValue());
86 … Literal(LiteralTag.METHOD, compiler.getCompilerDriver().getFuncInternalName(<ts.MethodDeclaration…
93                     compiler.compileExpression(<ts.Expression | ts.Identifier>prop.getValue());
110     createClassLiteralBuf(compiler, classBuffer, stmt, [baseVreg, classReg]);
112     compileUnCompiledProperty(compiler, properties, classReg);
117         let classScope = <Scope>compiler.getRecorder().getScopeOfNode(stmt);
128     compiler.popScope();
167 export function compileDefaultConstructor(compiler: Compiler, ctrNode: ts.ConstructorDeclaration) {
174     compileSuperCall(compiler, callNode, [], true);
175     compileConstructor(compiler, ctrNode, false);
178 function compileUnCompiledProperty(compiler: Compiler, properties: Property[], classReg: VReg) {
179     let pandaGen = compiler.getPandaGen();
188                 compiler.compileExpression(<ts.Expression>prop.getValue());
192                 compileUnCompiledVariable(compiler, prop, classReg);
196                 compiler.compileExpression((<ts.ComputedPropertyName>prop.getName()).expression);
198                 compileComputedProperty(compiler, prop, classReg, keyReg);
201                 setClassAccessor(pandaGen, compiler, classReg, prop);
209 function compileUnCompiledVariable(compiler: Compiler, prop: Property, classReg: VReg) {
210     let pandaGen = compiler.getPandaGen();
216 …flag = createClassMethodOrAccessor(compiler, classReg, proptoReg, tmpReg, <ts.MethodDeclaration>pr…
218         compiler.compileExpression(<ts.Expression | ts.Identifier>prop.getValue());
219 …      flag = setPrototypeAttributes(compiler, prop.getValue().parent, classReg, proptoReg, tmpReg);
228 function createClassLiteralBuf(compiler: Compiler, classBuffer: LiteralBuffer,
233     let ctorNode = compiler.getRecorder().getCtorOfClass(stmt);
234 …let internalName = compiler.getCompilerDriver().getInternalNameForCtor(stmt, <ts.ConstructorDeclar…
236     let pandaGen = compiler.getPandaGen();
243 export function compileDefaultInitClassMembers(compiler: Compiler, node: ts.ConstructorDeclaration)…
244     let pandaGen = compiler.getPandaGen();
255             compiler.getThis(node, thisReg);
257             compiler.compileExpression(decl.initializer);
273                     compiler.compileExpression(decl.name.expression);
291 export function compileReturnThis4Ctor(compiler: Compiler, node: ts.ConstructorDeclaration, unreach…
292     let pandaGen = compiler.getPandaGen();
299     compiler.getThis(node, thisReg);
302     checkValidUseSuperBeforeSuper(compiler, node);
308 export function compileConstructor(compiler: Compiler, node: ts.ConstructorDeclaration, unreachable…
309     let pandaGen = compiler.getPandaGen();
315             let lref = LReference.generateLReference(compiler, decl.name, true);
317                 compiler.compileExpression(decl.initializer);
329     compiler.getThis(node, thisReg);
331     checkValidUseSuperBeforeSuper(compiler, node);
337 export function compileSuperCall(compiler: Compiler, node: ts.CallExpression, args: VReg[], hasSpre…
338     let pandaGen = compiler.getPandaGen();
341     let curScope = <Scope>compiler.getCurrentScope();
344     compiler.setCallOpt(scope, "this");
345     compiler.setCallOpt(scope, "4newTarget");
368 …    createArrayFromElements(node, compiler, <ts.NodeArray<ts.Expression>>node.arguments, argArray);
369         loadCtorObj(node, compiler);
375         loadCtorObj(node, compiler);
382     checkValidUseSuperBeforeSuper(compiler, node);
387     compiler.setThis(node);
390 function loadCtorObj(node: ts.CallExpression, compiler: Compiler) {
391     let recorder = compiler.getRecorder();
392     let pandaGen = compiler.getPandaGen();
477 function compileHeritageClause(compiler: Compiler, node: ts.ClassLikeDeclaration) {
478     let pandaGen = compiler.getPandaGen();
484             compiler.compileExpression(exp.expression);
620 function compileComputedProperty(compiler: Compiler, prop: Property, classReg: VReg, keyReg: VReg) {
621     let pandaGen = compiler.getPandaGen();
626                 compiler.compileExpression(initializer);
634 …let flag = createClassMethodOrAccessor(compiler, classReg, protoReg, tmpReg, <ts.MethodDeclaration…
643 …   let getFlag = createClassMethodOrAccessor(compiler, classReg, getProtoReg, accessorReg, getter);
652 …      let setFlag = createClassMethodOrAccessor(compiler, classReg, setProtoReg, accesReg, setter);
663 function setClassAccessor(pandaGen: PandaGen, compiler: Compiler, objReg: VReg, prop: Property) {
676         flag = createClassMethodOrAccessor(compiler, objReg, tmpVreg, getterReg, getter);
681         flag = createClassMethodOrAccessor(compiler, objReg, tmpVreg, setterReg, setter);
698 function createClassMethodOrAccessor(compiler: Compiler, classReg: VReg, propReg: VReg, storeReg: V…
700     let pandaGen = compiler.getPandaGen();
702         createMethodOrAccessor(pandaGen, compiler, classReg, node);
710     createMethodOrAccessor(pandaGen, compiler, propReg, node);
733 export function setPrototypeAttributes(compiler: Compiler, node: ts.Node, classReg: VReg, propReg: …
734     let pandaGen = compiler.getPandaGen();
786 export function compileSuperProperty(compiler: Compiler, expr: ts.Expression, thisReg: VReg, prop: …
787     checkValidUseSuperBeforeSuper(compiler, expr);
788     let pandaGen = compiler.getPandaGen();
789     compiler.getThis(expr, thisReg);
794 export function checkValidUseSuperBeforeSuper(compiler: Compiler, node: ts.Node) {
795     let pandaGen = compiler.getPandaGen();
803     compiler.getThis(node, thisReg);