javascript - Should promises be avoided in synchronous functions?

I am currently trying to beautify some NodeJS legacy code
and doing so came up with this questions where I could not find any best-practice or
go-to-guide (if you know any, please share it with
me).

The aim is to not simply see
that one can combine synchronous and asynchronous code via Promises (this is clear), but
why one should e.g. go for synchronous code if the synchronous processing of a function
is clear. This means what disadvantages would it have to simply add a Promise to the
synchronous code? Are there any? E.g. in the runtime or, more important, in the
asynchronous process flow?

E.g. take the
following example for an async
function:

Foo.prototype.addNode =
            function addNode() {
 var self = this;
 return new Promise(function
            (resolve, reject) {
 var node = new Node(self.getNodes().getLastId() +
            1);
 resolve (self.getNodes().add(node));

            });

}

In
our business logic this function should indeed be async,
since this is called recursively in a promise
chain.

However, the function
add is handled synchronously, since this is a simple
Array.push() of a generic element with some
validation.

GenericElementList.prototype.add
            = function add(T) {
 if (this.T.length === 0) {

            this.T.push(T);

 this.typeOfT = T.constructor;
 return
            this;
 }
 else {
 if (!(T.constructor ===
            this.typeOfT)){
 this.T.push(T);
 return this;

            }
 else {
 throw new IllegalArgumentError('Invalid type of element
            to push into array! Was: ' + T.constructor.name + ' but should be: ' + this.typeOfT.name
            + '!');

 }

            }
};

(So to
avoid confusion: self.getNodes() returns an element
Node which is a GenericElement and the
GenericElementList is a list data structure for
GenericElements.)

Now
my question is: Would there be any disadvantages regarding runtime or process flow in
the asynchronous processing of these methods, if we would add a Promise to the
add-function? Are there any reasons to avoid that? Or would the
only disadvantage be some boilerplate code?