diff --git a/ts2panda/src/base/typeSystem.ts b/ts2panda/src/base/typeSystem.ts
index 18a04e51326805ea38334dfe9ec5af7fe4c5001e..780d81d46e15dd46df4c28536e0bde8de9e7db74 100644
--- a/ts2panda/src/base/typeSystem.ts
+++ b/ts2panda/src/base/typeSystem.ts
@@ -760,6 +760,7 @@ export class ArrayType extends BaseType {
 
 export class ObjectType extends BaseType {
     private properties: Map<string, number> = new Map<string, number>();
+    private methods: Array<number> = new Array<number>();
     typeIndex: number = PrimitiveType.ANY;
     shiftedTypeIndex: number = PrimitiveType.ANY;
 
@@ -767,16 +768,48 @@ export class ObjectType extends BaseType {
         super();
         this.typeIndex = this.getIndexFromTypeArrayBuffer(new PlaceHolderType());
         this.shiftedTypeIndex = this.typeIndex + literalBufferIndexShift;
-        this.fillInMembers(objNode);
+        this.fillInFieldsAndMethods(objNode);
         this.setTypeArrayBuffer(this, this.typeIndex);
     }
 
-    fillInMembers(objNode: ts.TypeLiteralNode) {
-        for (let member of objNode.members) {
-            let propertySig = <ts.PropertySignature>member;
-            let name = member.name ? member.name.getText() : "#undefined";
-            let typeIndex = this.getOrCreateRecordForTypeNode(propertySig.type, member.name);
-            this.properties.set(name, typeIndex);
+    private fillInMethods(member: ts.MethodSignature) {
+        if (this.typeChecker.isFromDefaultLib(member)) {
+            return;
+        }
+        let variableNode = member.name ? member.name : undefined;
+        let funcType = new FunctionType(<ts.MethodSignature>member);
+        if (variableNode) {
+            this.setVariable2Type(variableNode, funcType.shiftedTypeIndex);
+        }
+        let typeIndex = this.tryGetTypeIndex(member);
+        this.methods.push(typeIndex!);
+    }
+
+    private fillInFields(member) {
+        let propertySig = <ts.PropertySignature>member;
+        let name = member.name ? member.name.getText() : "#undefined";
+        let typeIndex = this.getOrCreateRecordForTypeNode(propertySig.type, member.name);
+        this.properties.set(name, typeIndex);
+    }
+
+    private fillInFieldsAndMethods(objNode: ts.TypeLiteralNode) {
+        if (objNode.members) {
+            for (let member of objNode.members) {
+                switch (member.kind) {
+                    case ts.SyntaxKind.MethodSignature:
+                        this.fillInMethods(<ts.MethodSignature>member);
+                        break;
+                    case ts.SyntaxKind.PropertySignature:
+                        this.fillInFields(<ts.PropertySignature>member);
+                        break;
+                    case ts.SyntaxKind.CallSignature:
+                    case ts.SyntaxKind.ConstructSignature:
+                        // Considering the complex cases of function overloads, call/construct signature is not recorded
+                    case ts.SyntaxKind.IndexSignature:
+                    default:
+                        break;
+                }
+            }
         }
     }
 
@@ -784,11 +817,14 @@ export class ObjectType extends BaseType {
         let objTypeBuf = new LiteralBuffer();
         let objLiterals: Array<Literal> = new Array<Literal>();
         objLiterals.push(new Literal(LiteralTag.INTEGER, L2Type.OBJECT));
-        objLiterals.push(new Literal(LiteralTag.INTEGER, this.properties.size));
+        objLiterals.push(new Literal(LiteralTag.INTEGER, this.properties.size + this.methods.length));
         this.properties.forEach((typeIndex, name) => {
             objLiterals.push(new Literal(LiteralTag.STRING, name));
             this.transferType2Literal(typeIndex, objLiterals);
         });
+        this.methods.forEach(method => {
+            this.transferType2Literal(method, objLiterals);
+        });
         objTypeBuf.addLiterals(...objLiterals);
         return objTypeBuf;
     }