}

    public object THREE_DOTS : KaParameterDefaultValueRenderer {
        override fun renderDefaultValue(analysisSession: KaSession, symbol: KaValueParameterSymbol, printer: PrettyPrinter) {
            if (symbol.hasDefaultValue) {
                printer.append("...")
            }
        }
    }
}

import org.gradle.declarative.dsl.model.annotations.Adding
import org.gradle.declarative.dsl.model.annotations.Builder
import org.gradle.declarative.dsl.model.annotations.Configuring
import org.gradle.declarative.dsl.model.annotations.HasDefaultValue
import org.gradle.declarative.dsl.model.annotations.Restricted


class TopLevelScope {
    @get:Restricted
    val plugins = PluginsBlock()

    @Configuring

            builder.typeBuilder.buildKtType(returnType.varargElementType())
        } else {
            builder.typeBuilder.buildKtType(returnType)
        }
    }

    override val hasDefaultValue: Boolean get() = withValidityAssertion { firSymbol.hasDefaultValue }

    override val annotations by cached {
        KaFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

import org.gradle.tooling.ToolingModelContract
import java.io.Serializable


interface DataProperty : Serializable {
    val name: String
    val valueType: DataTypeRef
    val mode: PropertyMode
    val hasDefaultValue: Boolean
    val isHiddenInDsl: Boolean
    val isDirectAccessOnly: Boolean

    @ToolingModelContract(subTypes = [
        PropertyMode.ReadWrite::class,
        PropertyMode.ReadOnly::class,

  explicit OpArgumentView(AttrSpec attr);
  explicit OpArgumentView(string type, string var, string def = "");

  string Declaration() const;
  string Initializer() const;
  bool HasDefaultValue() const;

 private:
  string type_name_;
  string variable_name_;
  string default_value_;
};

}  // namespace cpp
}  // namespace generator
}  // namespace tensorflow

}

string OpArgumentView::Initializer() const {
  if (default_value_.empty()) {
    return "";
  }
  return absl::Substitute(" = $0", default_value_);
}

bool OpArgumentView::HasDefaultValue() const { return !default_value_.empty(); }

OpArgumentView::OpArgumentView(string type, string var, string def)
    : type_name_(type), variable_name_(var), default_value_(def) {}

		if field.DataType != "" && field.HasDefaultValue && field.DefaultValueInterface == nil {
			schema.FieldsWithDefaultDBValue = append(schema.FieldsWithDefaultDBValue, field)
		}
	}

	if field := schema.PrioritizedPrimaryField; field != nil {
		switch field.GORMDataType {
		case Int, Uint:
			if _, ok := field.TagSettings["AUTOINCREMENT"]; !ok {
				if !field.HasDefaultValue || field.DefaultValueInterface != nil {

        get() = withValidityAssertion { KaEmptyAnnotationList(token) }

    override val name: Name
        get() = withValidityAssertion { Name.identifier("args") }

    override val hasDefaultValue: Boolean
        get() = withValidityAssertion { false }

    override val isVararg: Boolean
        get() = withValidityAssertion { true }

    override val isCrossinline: Boolean

			if !supportReturning {
				db.AddError(err)
			}
			return
		}

		if db.Statement.Schema != nil {
			if db.Statement.Schema.PrioritizedPrimaryField == nil || !db.Statement.Schema.PrioritizedPrimaryField.HasDefaultValue {
				return
			}
			pkField = db.Statement.Schema.PrioritizedPrimaryField
			pkFieldName = db.Statement.Schema.PrioritizedPrimaryField.DBName
		}

    string text = argument.Declaration();
    if (context_.mode == RendererContext::kHeader) {
      absl::StrAppend(&text, argument.Initializer());
    }
    if (argument.HasDefaultValue()) {
      args_with_default_val.push_back(text);
    } else {
      args_without_default_val.push_back(text);
    }
  }
  std::vector<string> arguments;
  arguments.reserve(args_without_default_val.size() +