starlark 0.13.0

An implementation of the Starlark language in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

/*
 * Copyright 2018 The Starlark in Rust Authors.
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use dupe::Dupe;

use crate::__derive_refs::param_spec::NativeCallableParam;
use crate::__derive_refs::param_spec::NativeCallableParamDefaultValue;
use crate::__derive_refs::param_spec::NativeCallableParamSpec;
use crate::docs::DocFunction;
use crate::docs::DocItem;
use crate::docs::DocMember;
use crate::docs::DocParam;
use crate::docs::DocParams;
use crate::docs::DocStringKind;
use crate::docs::DocType;
use crate::eval::runtime::params::display::PARAM_FMT_OPTIONAL;
use crate::typing::Ty;

/// A wrapper for the parameters to `GlobalsBuilder::set_function` and `MethodBuilder::set_method`
pub struct NativeCallableComponents {
    pub speculative_exec_safe: bool,
    pub rust_docstring: Option<&'static str>,
    pub param_spec: NativeCallableParamSpec,
    pub return_type: Ty,
}

impl NativeCallableComponents {
    fn doc_params(&self) -> DocParams {
        fn doc_param(p: &NativeCallableParam) -> DocParam {
            let NativeCallableParam { name, ty, required } = p;
            DocParam {
                name: (*name).to_owned(),
                docs: None,
                typ: ty.dupe(),
                default_value: match required {
                    None => None,
                    Some(NativeCallableParamDefaultValue::Optional) => {
                        Some(PARAM_FMT_OPTIONAL.to_owned())
                    }
                    Some(NativeCallableParamDefaultValue::Value(v)) => Some(v.to_value().to_repr()),
                },
            }
        }

        DocParams {
            pos_only: self.param_spec.pos_only.iter().map(doc_param).collect(),
            pos_or_named: self.param_spec.pos_or_named.iter().map(doc_param).collect(),
            args: self.param_spec.args.as_ref().map(doc_param),
            named_only: self.param_spec.named_only.iter().map(doc_param).collect(),
            kwargs: self.param_spec.kwargs.as_ref().map(doc_param),
        }
    }

    pub(crate) fn into_docs(self, as_type: Option<(Ty, DocType)>) -> DocItem {
        let func_docs = DocFunction::from_docstring(
            DocStringKind::Rust,
            self.doc_params(),
            self.return_type.clone(),
            self.rust_docstring,
        );
        match as_type {
            Some((_, ty_docs)) => DocItem::Type(DocType {
                constructor: Some(func_docs),
                ..ty_docs
            }),
            None => DocItem::Member(DocMember::Function(func_docs)),
        }
    }
}