Microsoft.Zing.Splicer.GenerateClassMethod C# (CSharp) Method

        private Class GenerateClassMethod(ZMethod zMethod, Interface x)
        {
            this.currentMethod = zMethod;
            Class newClass = (Class)Templates.GetTypeTemplateByName("ClassMethod");
            QualifiedIdentifier qi = (x == null)
                                     ? new QualifiedIdentifier(new Identifier("Z"), new Identifier("ZingMethod"))
                                     : new QualifiedIdentifier(x.Name, zMethod.Name);
            Replacer.Replace(newClass, new Identifier("__Method"), qi);

            if (x == null)
            {
                if (!zMethod.IsStatic)
                    GenerateThisParameter(newClass);
                Class interfaceClass = (Class)Templates.GetTypeTemplateByName("InterfaceMethod");
                for (int i = 0, n = interfaceClass.Members.Count; i < n; i++)
                {
                    newClass.Members.Add(interfaceClass.Members[i]);
                    interfaceClass.Members[i].DeclaringType = newClass;
                }

                Class inputsClass = (Class)Templates.GetMemberByName(newClass.Members, "InputVars");
                GenerateInputs(zMethod, inputsClass);

                Class outputsClass = (Class)Templates.GetMemberByName(newClass.Members, "OutputVars");
                GenerateOutputs(zMethod, outputsClass);
            }

            Class localsClass = (Class)Templates.GetMemberByName(newClass.Members, "LocalVars");
            GenerateLocals(zMethod, localsClass);

            Class extras = (Class)Templates.GetTypeTemplateByName(zMethod.IsStatic
                                         ? "StaticMethodExtras"
                                         : "InstanceMethodExtras");
            for (int i = 0, n = extras.Members.Count; i < n; i++)
            {
                newClass.Members.Add(extras.Members[i]);
                extras.Members[i].DeclaringType = newClass;
                Property p = extras.Members[i] as Property;

                if (p != null)
                {
                    if (p.Getter != null)
                        p.Getter.DeclaringType = newClass;
                    if (p.Setter != null)
                        p.Setter.DeclaringType = newClass;
                }
            }

            Replacer.Replace(newClass, newClass.Name, zMethod.Name);
            SetTypeId(newClass);

            ExtendMethodConstructor(newClass, zMethod);

            // If this method doesn't return concrete bool, then remove the helper
            // property for accessing bool return values.
            if (zMethod.ReturnType == SystemTypes.Boolean)
            {
                Property boolRetValProp = (Property)Templates.GetTypeTemplateByName("BooleanReturnValueProperty").Members[0];
                newClass.Members.Add(boolRetValProp);
                boolRetValProp.DeclaringType = newClass;
                newClass.Members.Add(boolRetValProp.Getter);
                boolRetValProp.Getter.DeclaringType = newClass;
            }

            // Clear the "Activated" attribute if we aren't...
            if (!zMethod.Activated)
                newClass.Attributes = new AttributeList(0);

            GenerateBasicBlocks(newClass, zMethod);
            this.currentMethod = null;

            return newClass;
        }