parentProjectId = AbsoluteId("Gradle")
    projectId = AbsoluteId("Gradle_Master")
    settingsRootId = AbsoluteId("GradleMaster")
    settingsRoot.name = "GradleMaster"
    addParameters("Branch" to "master")

        // Set the project id here, so we can use methods on the DslContext
        DslContext.projectId = AbsoluteId("Gradle_${branchName.toCapitalized()}")
        DslContext.addParameters("Branch" to branchName)
        return PromotionProject(VersionedSettingsBranch(branchName))
    }

    private fun gradleStep(steps: List<BuildStep>, index: Int): GradleBuildStep {

        classMetaData.addMethod(METHOD_NAME, TypeMetaData.VOID, null).addParameter('param1', new TypeMetaData("java.lang.Integer"))
        def overloadedCalculateMethod = classMetaData.addMethod('calculate', TypeMetaData.VOID, null)
        overloadedCalculateMethod.addParameter('x', new TypeMetaData("java.lang.Integer"))
        overloadedCalculateMethod.addParameter('y', new TypeMetaData("java.lang.String"))

    final MethodMetaData method = new MethodMetaData('method', owner)

    def formatsSignature() {
        method.returnType = new TypeMetaData('ReturnType')
        method.addParameter('param1', new TypeMetaData('ParamType'))
        method.addParameter('param2', new TypeMetaData('ParamType2'))

        expect:
        method.signature == 'ReturnType method(ParamType param1, ParamType2 param2)'

            MethodMetaData methodMetaData = new MethodMetaData(id, extensionDoc.getTargetClass().getClassMetaData());
            methodMetaData.addParameter("configClosure", new TypeMetaData(Closure.class.getName()));
            MethodDoc methodDoc = new MethodDoc(methodMetaData, Collections.singletonList(para));

  AbstractTensorHandlePtr x;
  {
    tracing::TracingTensorHandle* x_raw = nullptr;
    PartialTensorShape shape;
    Status s = dyn_cast<tracing::TracingContext>(ctx.get())->AddParameter(
        DT_FLOAT, shape, &x_raw);
    ASSERT_EQ(errors::OK, s.code()) << s.message();
    x.reset(x_raw);
  }

  PartialTensorShape shape;
  Status s = x->Shape(&shape);

        }

        return null;
    }

    public List<ParameterMetaData> getParameters() {
        return parameters;
    }

    public ParameterMetaData addParameter(String name, TypeMetaData type) {
        ParameterMetaData param = new ParameterMetaData(name);
        param.setType(type);
        parameters.add(param);
        return param;
    }

                                javaTypeParameterStack.addParameter(JavaTypeParameterImpl(typeParam), typeParamSymbol)
                            }
                        }
                    }

                    containingClassSymbol.typeParameterSymbols.zip(psiClass.typeParameters).forEach { (symbol, typeParameter) ->
                        javaTypeParameterStack.addParameter(JavaTypeParameterImpl(typeParameter), symbol)

 protected:
  explicit TracingContext(AbstractContextKind kind) : AbstractContext(kind) {}

 public:
  // Add a function parameter and return the corresponding tensor.
  virtual Status AddParameter(DataType dtype, const PartialTensorShape& shape,
                              TracingTensorHandle**) = 0;

  // Finalize this context and make a function out of it. The context is in a

            TypeMetaData typeMetaData = extractTypeName(parameter.getType());
            if (parameter.isVarArgs()) {
                typeMetaData.setVarargs();
            }
            method.addParameter(parameter.getNameAsString(), typeMetaData);
        }
    }

    @Override
    public void visit(FieldDeclaration fieldDeclaration, ClassMetaDataRepository<ClassMetaData> arg) {